138 lines
3.4 KiB
Go
138 lines
3.4 KiB
Go
package workspace
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
"github.com/Snider/Core/pkg/core"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/wailsapp/wails/v3/pkg/application"
|
|
)
|
|
|
|
// mockConfig is a mock implementation of the core.Config interface for testing.
|
|
type mockConfig struct {
|
|
values map[string]interface{}
|
|
}
|
|
|
|
func (m *mockConfig) Get(key string, out any) error {
|
|
val, ok := m.values[key]
|
|
if !ok {
|
|
return fmt.Errorf("key not found: %s", key)
|
|
}
|
|
// This is a simplified mock; a real one would use reflection to set `out`
|
|
switch v := out.(type) {
|
|
case *string:
|
|
*v = val.(string)
|
|
default:
|
|
return fmt.Errorf("unsupported type in mock config Get")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *mockConfig) Set(key string, v any) error {
|
|
m.values[key] = v
|
|
return nil
|
|
}
|
|
|
|
// MockMedium implements the Medium interface for testing purposes.
|
|
type MockMedium struct {
|
|
Files map[string]string
|
|
Dirs map[string]bool
|
|
}
|
|
|
|
func NewMockMedium() *MockMedium {
|
|
return &MockMedium{
|
|
Files: make(map[string]string),
|
|
Dirs: make(map[string]bool),
|
|
}
|
|
}
|
|
|
|
func (m *MockMedium) FileGet(path string) (string, error) {
|
|
content, ok := m.Files[path]
|
|
if !ok {
|
|
return "", assert.AnError // Simulate file not found error
|
|
}
|
|
return content, nil
|
|
}
|
|
|
|
func (m *MockMedium) FileSet(path, content string) error {
|
|
m.Files[path] = content
|
|
return nil
|
|
}
|
|
|
|
func (m *MockMedium) EnsureDir(path string) error {
|
|
m.Dirs[path] = true
|
|
return nil
|
|
}
|
|
|
|
func (m *MockMedium) IsFile(path string) bool {
|
|
_, exists := m.Files[path]
|
|
return exists
|
|
}
|
|
|
|
func (m *MockMedium) Read(path string) (string, error) {
|
|
return m.FileGet(path)
|
|
}
|
|
|
|
func (m *MockMedium) Write(path, content string) error {
|
|
return m.FileSet(path, content)
|
|
}
|
|
|
|
// newTestService creates a workspace service instance with mocked dependencies.
|
|
func newTestService(t *testing.T, workspaceDir string) (*Service, *MockMedium) {
|
|
coreInstance, err := core.New()
|
|
assert.NoError(t, err)
|
|
|
|
mockCfg := &mockConfig{values: map[string]interface{}{"workspaceDir": workspaceDir}}
|
|
coreInstance.RegisterService("config", mockCfg)
|
|
|
|
service, err := New()
|
|
assert.NoError(t, err)
|
|
|
|
service.Runtime = core.NewRuntime(coreInstance, Options{})
|
|
mockMedium := NewMockMedium()
|
|
service.medium = mockMedium
|
|
|
|
return service, mockMedium
|
|
}
|
|
|
|
func TestServiceStartup(t *testing.T) {
|
|
workspaceDir := "/tmp/workspace"
|
|
|
|
t.Run("existing valid list.json", func(t *testing.T) {
|
|
service, mockMedium := newTestService(t, workspaceDir)
|
|
|
|
expectedWorkspaceList := map[string]string{
|
|
"workspace1": "pubkey1",
|
|
"workspace2": "pubkey2",
|
|
}
|
|
listContent, _ := json.MarshalIndent(expectedWorkspaceList, "", " ")
|
|
listPath := filepath.Join(workspaceDir, listFile)
|
|
mockMedium.Files[listPath] = string(listContent)
|
|
|
|
err := service.ServiceStartup(context.Background(), application.ServiceOptions{})
|
|
|
|
assert.NoError(t, err)
|
|
// assert.Equal(t, expectedWorkspaceList, service.workspaceList) // This check is difficult with current implementation
|
|
assert.NotNil(t, service.activeWorkspace)
|
|
assert.Equal(t, defaultWorkspace, service.activeWorkspace.Name)
|
|
})
|
|
}
|
|
|
|
func TestCreateAndSwitchWorkspace(t *testing.T) {
|
|
workspaceDir := "/tmp/workspace"
|
|
service, _ := newTestService(t, workspaceDir)
|
|
|
|
// Create
|
|
workspaceID, err := service.CreateWorkspace("test", "password")
|
|
assert.NoError(t, err)
|
|
assert.NotEmpty(t, workspaceID)
|
|
|
|
// Switch
|
|
err = service.SwitchWorkspace(workspaceID)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, workspaceID, service.activeWorkspace.Name)
|
|
}
|