Implement controlled app launch (T-401)
This commit is contained in:
@@ -0,0 +1,288 @@
|
||||
package launch
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"softbox.local/core/storage"
|
||||
)
|
||||
|
||||
func TestServiceStartsOnlyVerifiedCurrentEntrypoint(t *testing.T) {
|
||||
store, appRoot := seedInstalledApp(t)
|
||||
launcher := &recordingLauncher{pid: 42}
|
||||
service := newService(t, store, launcher)
|
||||
|
||||
result, err := service.Start(Request{AppID: "test-app"})
|
||||
if err != nil {
|
||||
t.Fatalf("Start() error = %v", err)
|
||||
}
|
||||
if result != (Result{AppID: "test-app", PID: 42}) {
|
||||
t.Fatalf("result = %#v", result)
|
||||
}
|
||||
wantEntrypoint := filepath.Join(appRoot, "current", "bin", "App.exe")
|
||||
if launcher.command.Entrypoint != wantEntrypoint ||
|
||||
launcher.command.WorkingDirectory != filepath.Join(appRoot, "current", "bin") ||
|
||||
!launcher.command.RequiresAdmin {
|
||||
t.Fatalf("command = %#v", launcher.command)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServiceRejectsUnsafeOrUnavailableLaunchStates(t *testing.T) {
|
||||
errCompatibility := errors.New("compatibility unavailable")
|
||||
errAuthorization := errors.New("authorization unavailable")
|
||||
errTargetState := errors.New("target state unavailable")
|
||||
errStart := errors.New("start failed")
|
||||
tests := []struct {
|
||||
name string
|
||||
mutate func(*storage.InstalledApp, string)
|
||||
service func(*Service)
|
||||
wantErr error
|
||||
wantCode FailureCode
|
||||
}{
|
||||
{
|
||||
name: "missing legacy metadata",
|
||||
mutate: func(record *storage.InstalledApp, _ string) {
|
||||
record.Entrypoint = ""
|
||||
},
|
||||
wantErr: ErrLaunchMetadata,
|
||||
wantCode: FailureCodeLaunchMetadataInvalid,
|
||||
},
|
||||
{
|
||||
name: "entrypoint is absent",
|
||||
mutate: func(_ *storage.InstalledApp, appRoot string) {
|
||||
if err := os.Remove(filepath.Join(appRoot, "current", "bin", "App.exe")); err != nil {
|
||||
t.Fatalf("remove entrypoint: %v", err)
|
||||
}
|
||||
},
|
||||
wantErr: ErrEntrypointMissing,
|
||||
wantCode: FailureCodeEntrypointMissing,
|
||||
},
|
||||
{
|
||||
name: "unsafe current layout",
|
||||
service: func(service *Service) {
|
||||
service.records = resolverFunc(func(string) (storage.InstalledApp, string, error) {
|
||||
return storage.InstalledApp{}, "", storage.ErrStorageLayoutUnsafe
|
||||
})
|
||||
},
|
||||
wantErr: ErrLaunchTargetUnsafe,
|
||||
wantCode: FailureCodeLaunchTargetUnsafe,
|
||||
},
|
||||
{
|
||||
name: "incompatible system",
|
||||
service: func(service *Service) {
|
||||
service.compatibility = compatibilityFunc(func(string) (bool, error) { return false, nil })
|
||||
},
|
||||
wantErr: ErrAppIncompatible,
|
||||
wantCode: FailureCodeAppIncompatible,
|
||||
},
|
||||
{
|
||||
name: "compatibility failure",
|
||||
service: func(service *Service) {
|
||||
service.compatibility = compatibilityFunc(func(string) (bool, error) { return false, errCompatibility })
|
||||
},
|
||||
wantErr: errCompatibility,
|
||||
wantCode: FailureCodeCompatibilityUnavailable,
|
||||
},
|
||||
{
|
||||
name: "unauthorized",
|
||||
service: func(service *Service) {
|
||||
service.authorization = authorizationFunc(func(string) (bool, error) { return false, nil })
|
||||
},
|
||||
wantErr: ErrLaunchUnauthorized,
|
||||
wantCode: FailureCodeLaunchUnauthorized,
|
||||
},
|
||||
{
|
||||
name: "authorization failure",
|
||||
service: func(service *Service) {
|
||||
service.authorization = authorizationFunc(func(string) (bool, error) { return false, errAuthorization })
|
||||
},
|
||||
wantErr: errAuthorization,
|
||||
wantCode: FailureCodeAuthorizationFailed,
|
||||
},
|
||||
{
|
||||
name: "already running",
|
||||
service: func(service *Service) {
|
||||
service.targetState = targetStateFunc(func(string, string) (bool, error) { return true, nil })
|
||||
},
|
||||
wantErr: ErrAppRunning,
|
||||
wantCode: FailureCodeAppRunning,
|
||||
},
|
||||
{
|
||||
name: "target state failure",
|
||||
service: func(service *Service) {
|
||||
service.targetState = targetStateFunc(func(string, string) (bool, error) { return false, errTargetState })
|
||||
},
|
||||
wantErr: errTargetState,
|
||||
wantCode: FailureCodeTargetStateUnavailable,
|
||||
},
|
||||
{
|
||||
name: "launcher failure",
|
||||
service: func(service *Service) {
|
||||
service.launcher = &recordingLauncher{err: errStart}
|
||||
},
|
||||
wantErr: errStart,
|
||||
wantCode: FailureCodeLaunchFailed,
|
||||
},
|
||||
}
|
||||
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
store, appRoot := seedInstalledApp(t)
|
||||
record, found, err := store.Read("test-app")
|
||||
if err != nil || !found {
|
||||
t.Fatalf("Read() found=%t err=%v", found, err)
|
||||
}
|
||||
if test.mutate != nil {
|
||||
test.mutate(&record, appRoot)
|
||||
if err := store.Write(record); err != nil {
|
||||
t.Fatalf("Write() error = %v", err)
|
||||
}
|
||||
}
|
||||
launcher := &recordingLauncher{pid: 42}
|
||||
service := newService(t, store, launcher)
|
||||
if test.service != nil {
|
||||
test.service(service)
|
||||
}
|
||||
|
||||
_, err = service.Start(Request{AppID: "test-app"})
|
||||
if !errors.Is(err, test.wantErr) {
|
||||
t.Fatalf("Start() error = %v, want %v", err, test.wantErr)
|
||||
}
|
||||
if code := launchErrorCode(t, err); code != test.wantCode {
|
||||
t.Fatalf("code = %q, want %q", code, test.wantCode)
|
||||
}
|
||||
if launcher.calls != 0 {
|
||||
t.Fatalf("launcher calls = %d, want 0", launcher.calls)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewServiceRequiresEveryDependency(t *testing.T) {
|
||||
store, _ := seedInstalledApp(t)
|
||||
config := ServiceConfig{
|
||||
Records: store,
|
||||
Compatibility: compatibilityFunc(func(string) (bool, error) { return true, nil }),
|
||||
Authorization: authorizationFunc(func(string) (bool, error) { return true, nil }),
|
||||
TargetState: targetStateFunc(func(string, string) (bool, error) { return false, nil }),
|
||||
Launcher: &recordingLauncher{pid: 1},
|
||||
}
|
||||
for _, test := range []struct {
|
||||
name string
|
||||
mutate func(*ServiceConfig)
|
||||
}{
|
||||
{"records", func(config *ServiceConfig) { config.Records = nil }},
|
||||
{"compatibility", func(config *ServiceConfig) { config.Compatibility = nil }},
|
||||
{"authorization", func(config *ServiceConfig) { config.Authorization = nil }},
|
||||
{"target state", func(config *ServiceConfig) { config.TargetState = nil }},
|
||||
{"launcher", func(config *ServiceConfig) { config.Launcher = nil }},
|
||||
} {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
candidate := config
|
||||
test.mutate(&candidate)
|
||||
if _, err := NewService(candidate); !errors.Is(err, ErrLaunchConfig) {
|
||||
t.Fatalf("NewService() error = %v, want %v", err, ErrLaunchConfig)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func seedInstalledApp(t *testing.T) (*storage.InstalledAppStore, string) {
|
||||
t.Helper()
|
||||
appsRoot := filepath.Join(t.TempDir(), "apps")
|
||||
store := storage.NewInstalledAppStore(appsRoot)
|
||||
record := storage.InstalledApp{
|
||||
SchemaVersion: 1,
|
||||
ID: "test-app",
|
||||
Version: "1.2.3",
|
||||
Architecture: "amd64",
|
||||
Channel: "stable",
|
||||
Entrypoint: "bin/App.exe",
|
||||
WorkingDirectory: "bin",
|
||||
MinOS: "windows-10",
|
||||
RequiresAdmin: true,
|
||||
Files: []storage.InstalledFile{{
|
||||
Path: "bin/App.exe",
|
||||
Size: 1,
|
||||
SHA256: "0000000000000000000000000000000000000000000000000000000000000000",
|
||||
}},
|
||||
}
|
||||
if err := store.Write(record); err != nil {
|
||||
t.Fatalf("Write() error = %v", err)
|
||||
}
|
||||
appRoot := filepath.Join(appsRoot, record.ID)
|
||||
entrypoint := filepath.Join(appRoot, "current", "bin", "App.exe")
|
||||
if err := os.MkdirAll(filepath.Dir(entrypoint), 0o700); err != nil {
|
||||
t.Fatalf("MkdirAll() error = %v", err)
|
||||
}
|
||||
if err := os.WriteFile(entrypoint, []byte("x"), 0o700); err != nil {
|
||||
t.Fatalf("WriteFile() error = %v", err)
|
||||
}
|
||||
return store, appRoot
|
||||
}
|
||||
|
||||
func newService(t *testing.T, records InstalledAppResolver, launcher ProcessLauncher) *Service {
|
||||
t.Helper()
|
||||
service, err := NewService(ServiceConfig{
|
||||
Records: records,
|
||||
Compatibility: compatibilityFunc(func(string) (bool, error) { return true, nil }),
|
||||
Authorization: authorizationFunc(func(string) (bool, error) { return true, nil }),
|
||||
TargetState: targetStateFunc(func(string, string) (bool, error) { return false, nil }),
|
||||
Launcher: launcher,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("NewService() error = %v", err)
|
||||
}
|
||||
return service
|
||||
}
|
||||
|
||||
func launchErrorCode(t *testing.T, err error) FailureCode {
|
||||
t.Helper()
|
||||
var launchErr *Error
|
||||
if !errors.As(err, &launchErr) {
|
||||
t.Fatalf("error = %v, want launch Error", err)
|
||||
}
|
||||
return launchErr.Code
|
||||
}
|
||||
|
||||
type compatibilityFunc func(string) (bool, error)
|
||||
|
||||
type resolverFunc func(string) (storage.InstalledApp, string, error)
|
||||
|
||||
func (resolver resolverFunc) ResolveCurrent(appID string) (storage.InstalledApp, string, error) {
|
||||
return resolver(appID)
|
||||
}
|
||||
|
||||
func (checker compatibilityFunc) IsCompatible(minOS string) (bool, error) {
|
||||
return checker(minOS)
|
||||
}
|
||||
|
||||
type authorizationFunc func(string) (bool, error)
|
||||
|
||||
func (checker authorizationFunc) IsAuthorized(appID string) (bool, error) {
|
||||
return checker(appID)
|
||||
}
|
||||
|
||||
type targetStateFunc func(string, string) (bool, error)
|
||||
|
||||
func (checker targetStateFunc) IsRunning(appID, entrypoint string) (bool, error) {
|
||||
return checker(appID, entrypoint)
|
||||
}
|
||||
|
||||
type recordingLauncher struct {
|
||||
command Command
|
||||
pid int
|
||||
err error
|
||||
calls int
|
||||
}
|
||||
|
||||
func (launcher *recordingLauncher) Start(command Command) (int, error) {
|
||||
launcher.calls++
|
||||
launcher.command = command
|
||||
if launcher.err != nil {
|
||||
return 0, launcher.err
|
||||
}
|
||||
return launcher.pid, nil
|
||||
}
|
||||
Reference in New Issue
Block a user