tests: fix sync tests

Author: FabianKramm

cmd/sync.go

@@ -123,8 +123,8 @@ func (cmd *SyncCmd) Run(f factory.Factory) error {
 	}
 
 	// Switch working directory
-	if cmd.GlobalFlags.ConfigPath != "" {
-		_, err := os.Stat(cmd.GlobalFlags.ConfigPath)
+	if cmd.ConfigPath != "" {
+		_, err := os.Stat(cmd.ConfigPath)
 		if err != nil {
 			return errors.Errorf("--config is specified, but config %s cannot be loaded: %v", cmd.GlobalFlags.ConfigPath, err)
 		}
@@ -251,6 +251,8 @@ func (cmd *SyncCmd) Run(f factory.Factory) error {
 					break
 				}
 			}
+		} else {
+			syncConfig = syncConfigs[0]
 		}
 	}
 
@@ -272,7 +274,7 @@ func (cmd *SyncCmd) Run(f factory.Factory) error {
 
 	// Start sync
 	options = options.WithSkipInitContainers(true)
-	return sync.StartSyncFromCmd(ctx, targetselector.NewTargetSelector(options), syncConfig.syncConfig, cmd.NoWatch, cmd.Verbose)
+	return sync.StartSyncFromCmd(ctx, targetselector.NewTargetSelector(options), syncConfig.devPod.Name, syncConfig.syncConfig, cmd.NoWatch, cmd.Verbose)
 }
 
 func fromSyncConfig(devPod *latest.DevPod, containerName string, sc *latest.SyncConfig) (nameConfig, error) {

e2e/tests/dependencies/dependencies.go

@@ -38,7 +38,7 @@ var _ = DevSpaceDescribe("dependencies", func() {
 		kubeClient, err = kube.NewKubeHelper()
 	})
 
-	ginkgo.FIt("should skip equal dependencies", func() {
+	ginkgo.It("should skip equal dependencies", func() {
 		tempDir, err := framework.CopyToTempDir("tests/dependencies/testdata/overlapping")
 		framework.ExpectNoError(err)
 		defer framework.CleanupTempDir(initialDir, tempDir)

e2e/tests/sync/sync.go

@@ -90,6 +90,7 @@ var _ = DevSpaceDescribe("sync", func() {
 		framework.ExpectNoError(err)
 
 		// rerun sync command
+		syncCmd.Ctx = nil
 		err = syncCmd.Run(f)
 		framework.ExpectNoError(err)
 
@@ -482,7 +483,8 @@ var _ = DevSpaceDescribe("sync", func() {
 				Namespace:  ns,
 				ConfigPath: "devspace.yaml",
 			},
-			Ctx: cancelCtx,
+			Wait: true,
+			Ctx:  cancelCtx,
 		}
 
 		// start the command

pkg/devspace/services/portforwarding/portforwarding.go

@@ -160,6 +160,10 @@ func startForwarding(ctx *devspacecontext.Context, name string, portMappings []*
 	case <-readyChan:
 		ctx.Log.Donef("Port forwarding started on %s (%s/%s)", strings.Join(ports, ", "), pod.Namespace, pod.Name)
 	case err := <-errorChan:
+		if ctx.IsDone() {
+			return nil
+		}
+
 		return errors.Wrap(err, "forward ports")
 	case <-time.After(20 * time.Second):
 		return errors.Errorf("Timeout waiting for port forwarding to start")
@@ -172,6 +176,11 @@ func startForwarding(ctx *devspacecontext.Context, name string, portMappings []*
 			pf.Close()
 			stopPortForwarding(ctx, name, portMappings, fileLog, parent)
 		case err := <-errorChan:
+			if ctx.IsDone() {
+				pf.Close()
+				stopPortForwarding(ctx, name, portMappings, fileLog, parent)
+				return nil
+			}
 			if err != nil {
 				fileLog.Errorf("Portforwarding restarting, because: %v", err)
 				sync.PrintPodError(ctx.Context, ctx.KubeClient, pod, fileLog)

pkg/devspace/services/portforwarding/reverse_portforwarding.go

@@ -62,6 +62,13 @@ func startReversePortForwarding(ctx *devspacecontext.Context, name, arch string,
 			_ = stdoutWriter.Close()
 			doneReverseForwarding(ctx, name, portForwarding, fileLog, parent)
 		case err := <-errorChan:
+			if ctx.IsDone() {
+				close(closeChan)
+				_ = stdinWriter.Close()
+				_ = stdoutWriter.Close()
+				doneReverseForwarding(ctx, name, portForwarding, fileLog, parent)
+				return nil
+			}
 			if err != nil {
 				fileLog.Errorf("Reverse portforwarding restarting, because: %v", err)
 				sync.PrintPodError(ctx.Context, ctx.KubeClient, container.Pod, fileLog)

pkg/devspace/services/sync/controller.go

@@ -132,6 +132,9 @@ func (c *controller) startWithWait(ctx *devspacecontext.Context, options *Option
 				if pluginErr != nil {
 					return pluginErr
 				}
+				if ctx.IsDone() {
+					return nil
+				}
 				return errors.Wrap(err, "initial sync")
 			case <-onInitUploadDone:
 				uploadDone = true
@@ -176,6 +179,10 @@ func (c *controller) startWithWait(ctx *devspacecontext.Context, options *Option
 			case <-ctx.Context.Done():
 				syncStop(ctx, client, options, parent)
 			case err = <-onError:
+				if ctx.IsDone() {
+					syncStop(ctx, client, options, parent)
+					return nil
+				}
 				hook.LogExecuteHooks(ctx.WithLogger(options.SyncLog), map[string]interface{}{
 					"sync_config": options.SyncConfig,
 					"ERROR":       err,

pkg/devspace/services/sync/sync.go

@@ -12,9 +12,10 @@ import (
 )
 
 // StartSyncFromCmd starts a new sync from command
-func StartSyncFromCmd(ctx *devspacecontext.Context, selector targetselector.TargetSelector, syncConfig *latest.SyncConfig, noWatch, verbose bool) error {
+func StartSyncFromCmd(ctx *devspacecontext.Context, selector targetselector.TargetSelector, name string, syncConfig *latest.SyncConfig, noWatch, verbose bool) error {
 	ctx, parent := ctx.WithNewTomb()
 	options := &Options{
+		Name:           name,
 		SyncConfig:     syncConfig,
 		Selector:       selector,
 		RestartOnError: true,
@@ -25,23 +26,35 @@ func StartSyncFromCmd(ctx *devspacecontext.Context, selector targetselector.Targ
 
 	// Start the tomb
 	<-parent.NotifyGo(func() error {
+		// this is needed as otherwise the context
+		// is cancelled alongside the tomb
+		parent.Go(func() error {
+			<-ctx.Context.Done()
+			return nil
+		})
+
 		return NewController().Start(ctx, options, parent)
 	})
 
 	// Handle no watch
 	if noWatch {
-		parent.Kill(nil)
-		_ = parent.Wait()
-		return nil
+		select {
+		case <-parent.Dead():
+			return parent.Err()
+		default:
+			parent.Kill(nil)
+			_ = parent.Wait()
+			return nil
+		}
 	}
 
 	// Handle interrupt
 	select {
+	case <-parent.Dead():
+		return parent.Err()
 	case <-ctx.Context.Done():
 		_ = parent.Wait()
 		return nil
-	case <-parent.Dead():
-		return parent.Err()
 	}
 }
 

pkg/devspace/services/terminal/terminal.go

@@ -184,11 +184,13 @@ fi`,
 		<-errChan
 		return nil
 	case err = <-errChan:
+		if ctx.IsDone() {
+			return nil
+		}
+
 		if err != nil {
 			// check if context is done
-			if ctx.IsDone() {
-				return nil
-			} else if exitError, ok := err.(kubectlExec.CodeExitError); ok {
+			if exitError, ok := err.(kubectlExec.CodeExitError); ok {
 				// Expected exit codes are (https://shapeshed.com/unix-exit-codes/):
 				// 1 - Catchall for general errors
 				// 2 - Misuse of shell builtins (according to Bash documentation)