add module test with core imports

Author: systemshift

test/mock_module.go

@@ -1,160 +1,137 @@
 package test
 
 import (
-	"memex/pkg/types"
+	"memex/internal/memex/core"
 )
 
-// mockModule implements types.Module for testing
-type mockModule struct {
+// MockModule implements core.Module for testing
+type MockModule struct {
 	id          string
 	name        string
 	description string
-	commands    []types.Command
+	commands    []core.Command
 	initCalled  bool
 	lastCommand string
 	lastArgs    []string
 }
 
-func (m *mockModule) ID() string {
+func NewMockModule() *MockModule {
+	return &MockModule{
+		id:          "mock",
+		name:        "Mock Module",
+		description: "A mock module for testing",
+		commands:    make([]core.Command, 0),
+	}
+}
+
+func (m *MockModule) ID() string {
 	return m.id
 }
 
-func (m *mockModule) Name() string {
+func (m *MockModule) Name() string {
 	return m.name
 }
 
-func (m *mockModule) Description() string {
+func (m *MockModule) Description() string {
 	return m.description
 }
 
-func (m *mockModule) Init(repo types.Repository) error {
+func (m *MockModule) Init(repo core.Repository) error {
 	m.initCalled = true
 	return nil
 }
 
-func (m *mockModule) Commands() []types.Command {
+func (m *MockModule) Commands() []core.Command {
 	return m.commands
 }
 
-func (m *mockModule) HandleCommand(cmd string, args []string) error {
+func (m *MockModule) HandleCommand(cmd string, args []string) error {
 	m.lastCommand = cmd
 	m.lastArgs = args
 	return nil
 }
 
-// mockShutdownModule extends mockModule with shutdown capability
-type mockShutdownModule struct {
-	mockModule
-	shutdownCalled bool
-}
-
-func (m *mockShutdownModule) Shutdown() error {
-	m.shutdownCalled = true
-	return nil
-}
-
-// mockRepository implements types.ModuleRepository for testing
-type mockRepository struct {
-	modules   map[string]types.Module
-	loader    types.ModuleLoader
-	discovery types.ModuleDiscovery
+// MockRepository implements core.Repository for testing
+type MockRepository struct {
+	modules map[string]core.Module
+	nodes   map[string]*core.Node
+	links   map[string][]*core.Link
 }
 
-func newMockRepository() *mockRepository {
-	return &mockRepository{
-		modules:   make(map[string]types.Module),
-		loader:    &mockModuleLoader{},
-		discovery: &mockModuleDiscovery{},
+func NewMockRepository() *MockRepository {
+	return &MockRepository{
+		modules: make(map[string]core.Module),
+		nodes:   make(map[string]*core.Node),
+		links:   make(map[string][]*core.Link),
 	}
 }
 
-func (r *mockRepository) GetLoader() types.ModuleLoader {
-	return r.loader
-}
-
-func (r *mockRepository) GetDiscovery() types.ModuleDiscovery {
-	return r.discovery
-}
-
-// mockModuleLoader implements types.ModuleLoader for testing
-type mockModuleLoader struct{}
-
-func (l *mockModuleLoader) AddPath(path string)                          {}
-func (l *mockModuleLoader) AddDevPath(moduleID, path string)             {}
-func (l *mockModuleLoader) LoadModule(id string, mod types.Module) error { return nil }
-func (l *mockModuleLoader) UnloadModule(id string) error                 { return nil }
-func (l *mockModuleLoader) UnloadAll() error                             { return nil }
-func (l *mockModuleLoader) IsDevModule(moduleID string) bool             { return false }
-func (l *mockModuleLoader) GetDevPath(moduleID string) (string, bool)    { return "", false }
-
-// mockModuleDiscovery implements types.ModuleDiscovery for testing
-type mockModuleDiscovery struct{}
-
-func (d *mockModuleDiscovery) DiscoverModules() error                { return nil }
-func (d *mockModuleDiscovery) ValidateModule(mod types.Module) error { return nil }
-
-func (r *mockRepository) AddNode(content []byte, nodeType string, meta map[string]interface{}) (string, error) {
+func (r *MockRepository) AddNode(content []byte, nodeType string, meta map[string]interface{}) (string, error) {
 	return "test-id", nil
 }
 
-func (r *mockRepository) AddNodeWithID(id string, content []byte, nodeType string, meta map[string]interface{}) error {
+func (r *MockRepository) AddNodeWithID(id string, content []byte, nodeType string, meta map[string]interface{}) error {
 	return nil
 }
 
-func (r *mockRepository) GetNode(id string) (*types.Node, error) {
-	return nil, nil
+func (r *MockRepository) GetNode(id string) (*core.Node, error) {
+	return r.nodes[id], nil
 }
 
-func (r *mockRepository) DeleteNode(id string) error {
+func (r *MockRepository) DeleteNode(id string) error {
 	return nil
 }
 
-func (r *mockRepository) ListNodes() ([]string, error) {
-	return nil, nil
+func (r *MockRepository) ListNodes() ([]string, error) {
+	ids := make([]string, 0, len(r.nodes))
+	for id := range r.nodes {
+		ids = append(ids, id)
+	}
+	return ids, nil
 }
 
-func (r *mockRepository) GetContent(id string) ([]byte, error) {
+func (r *MockRepository) GetContent(id string) ([]byte, error) {
 	return nil, nil
 }
 
-func (r *mockRepository) AddLink(source, target, linkType string, meta map[string]interface{}) error {
+func (r *MockRepository) AddLink(source, target, linkType string, meta map[string]interface{}) error {
 	return nil
 }
 
-func (r *mockRepository) GetLinks(nodeID string) ([]*types.Link, error) {
-	return nil, nil
+func (r *MockRepository) GetLinks(nodeID string) ([]*core.Link, error) {
+	return r.links[nodeID], nil
 }
 
-func (r *mockRepository) DeleteLink(source, target, linkType string) error {
+func (r *MockRepository) DeleteLink(source, target, linkType string) error {
 	return nil
 }
 
-func (r *mockRepository) ListModules() []types.Module {
-	modules := make([]types.Module, 0, len(r.modules))
+func (r *MockRepository) ListModules() []core.Module {
+	modules := make([]core.Module, 0, len(r.modules))
 	for _, mod := range r.modules {
 		modules = append(modules, mod)
 	}
 	return modules
 }
 
-func (r *mockRepository) GetModule(id string) (types.Module, bool) {
+func (r *MockRepository) GetModule(id string) (core.Module, bool) {
 	mod, exists := r.modules[id]
 	return mod, exists
 }
 
-func (r *mockRepository) RegisterModule(module types.Module) error {
-	r.modules[module.ID()] = module
+func (r *MockRepository) RegisterModule(m core.Module) error {
+	r.modules[m.ID()] = m
 	return nil
 }
 
-func (r *mockRepository) QueryNodesByModule(moduleID string) ([]*types.Node, error) {
+func (r *MockRepository) QueryNodesByModule(moduleID string) ([]*core.Node, error) {
 	return nil, nil
 }
 
-func (r *mockRepository) QueryLinksByModule(moduleID string) ([]*types.Link, error) {
+func (r *MockRepository) QueryLinksByModule(moduleID string) ([]*core.Link, error) {
 	return nil, nil
 }
 
-func (r *mockRepository) Close() error {
+func (r *MockRepository) Close() error {
 	return nil
 }