Implement controlled app launch (T-401)

core/application/install/service_test.go

@@ -45,6 +45,10 @@ func TestInstallServiceInstallsVerifiedPackageAndRecordsPayloadFiles(t *testing.
 	if record.Version != "1.2.3" || len(record.Files) != 2 {
 		t.Fatalf("record = %#v", record)
 	}
+	if record.Entrypoint != "bin/App.exe" || record.WorkingDirectory != "." ||
+		record.MinOS != "windows-10" || record.RequiresAdmin {
+		t.Fatalf("launch metadata = %#v", record)
+	}
 	if record.Files[0].Path != "bin/App.exe" || record.Files[0].Size != int64(len("new executable")) {
 		t.Fatalf("record first file = %#v", record.Files[0])
 	}
@@ -184,6 +188,101 @@ func TestInstallServiceRollsBackHealthAndRecordWriteFailure(t *testing.T) {
 	}
 }
 
+func TestInstallServiceRechecksTargetImmediatelyBeforeUpdateSwitch(t *testing.T) {
+	appsRoot := filepath.Join(t.TempDir(), "apps")
+	store := storage.NewInstalledAppStore(appsRoot)
+	oldArchive, oldPackage := writeInstallPackage(t, "1.0.0", "old executable")
+	initial := newInstallService(t, store, func(string) error { return nil })
+	if _, err := initial.Install(InstallRequest{
+		Entry:        installEntry(oldPackage, "1.0.0"),
+		Architecture: catalog.ArchitectureAMD64,
+		DownloadPath: oldArchive,
+	}); err != nil {
+		t.Fatalf("initial Install() error = %v", err)
+	}
+
+	archivePath, publishedPackage := writeInstallPackage(t, "1.1.0", "new executable")
+	appRoot := filepath.Join(appsRoot, "test-app")
+	oldRecord := mustReadFile(t, filepath.Join(appRoot, "installed-app.json"))
+	targetErr := errors.New("target probe failed")
+	tests := []struct {
+		name     string
+		probe    func(int) (bool, error)
+		wantErr  error
+		wantCode FailureCode
+	}{
+		{
+			name: "target starts during extraction",
+			probe: func(call int) (bool, error) {
+				return call == 2, nil
+			},
+			wantErr:  ErrTargetRunning,
+			wantCode: FailureCodeAppRunning,
+		},
+		{
+			name: "target state fails at switch",
+			probe: func(call int) (bool, error) {
+				if call == 2 {
+					return false, targetErr
+				}
+				return false, nil
+			},
+			wantErr:  targetErr,
+			wantCode: FailureCodeTargetStateUnavailable,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			calls := 0
+			service := newInstallServiceWithCheckers(
+				t,
+				store,
+				func(string) error { return nil },
+				diskSpaceCheckerFunc(func(string) (int64, error) {
+					return StagingDiskReserveBytes + 64*1024, nil
+				}),
+				targetStateCheckerFunc(func(appID, entrypoint string) (bool, error) {
+					calls++
+					if appID != "test-app" || entrypoint != filepath.Join(appRoot, "current", "bin", "App.exe") {
+						t.Fatalf("target check = (%q, %q)", appID, entrypoint)
+					}
+					return test.probe(calls)
+				}),
+			)
+
+			_, err := service.Install(InstallRequest{
+				Entry:        installEntry(publishedPackage, "1.1.0"),
+				Architecture: catalog.ArchitectureAMD64,
+				DownloadPath: archivePath,
+			})
+			if !errors.Is(err, test.wantErr) {
+				t.Fatalf("Install() error = %v, want %v", err, test.wantErr)
+			}
+			if stage := installErrorStage(t, err); stage != InstallStageSwitch {
+				t.Fatalf("stage = %q, want %q", stage, InstallStageSwitch)
+			}
+			if code := installErrorCode(t, err); code != test.wantCode {
+				t.Fatalf("code = %q, want %q", code, test.wantCode)
+			}
+			if calls != 2 {
+				t.Fatalf("target check calls = %d, want 2", calls)
+			}
+			if got := mustReadFile(t, filepath.Join(appRoot, "current", "bin", "App.exe")); got != "old executable" {
+				t.Fatalf("current after failed update = %q", got)
+			}
+			if got := mustReadFile(t, filepath.Join(appRoot, "installed-app.json")); got != oldRecord {
+				t.Fatal("installed-app record changed after failed update")
+			}
+			for _, path := range []string{"staging", "backup", "install-transaction.json"} {
+				if _, statErr := os.Stat(filepath.Join(appRoot, path)); !os.IsNotExist(statErr) {
+					t.Fatalf("failed update left %s, stat error = %v", path, statErr)
+				}
+			}
+		})
+	}
+}
+
 func TestNewInstallServiceRequiresPreflightCheckers(t *testing.T) {
 	extractor, err := installer.NewExtractor(installTestLimits())
 	if err != nil {