From 94419beaeff7001675e4ebf117daeff4107ec5b2 Mon Sep 17 00:00:00 2001
From: rupinder-syngh <rupinder.singh@thewitslab.com>
Date: Thu, 3 Apr 2025 19:32:30 +0530
Subject: [PATCH] fix: Test case

---
 pkg/plugin/manager_test.go | 2475 ++++++++++++------------------------
 1 file changed, 839 insertions(+), 1636 deletions(-)

diff --git a/pkg/plugin/manager_test.go b/pkg/plugin/manager_test.go
index b5f2104..f4c38a5 100644
--- a/pkg/plugin/manager_test.go
+++ b/pkg/plugin/manager_test.go
@@ -1,1764 +1,967 @@
 package plugin
 
 import (
+	"archive/zip"
 	"context"
 	"errors"
 	"fmt"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"plugin"
-	"strings"
 	"testing"
-	"time"
 
-	"archive/zip"
-
-	"github.com/beckn/beckn-onix/pkg/model"
 	"github.com/beckn/beckn-onix/pkg/plugin/definition"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
-// Mock implementations of plugin interfaces
-type MockSigner struct{}
-
-func (m *MockSigner) Sign(ctx context.Context, body []byte, privateKeyBase64 string, createdAt, expiresAt int64) (string, error) {
-	return "mock_signature", nil
+// Mock implementations for testing
+type mockPublisher struct {
+	definition.Publisher
+	err error
 }
 
-func (m *MockSigner) Close() error {
-	return nil
+type mockSchemaValidator struct {
+	definition.SchemaValidator
+	err error
 }
 
-type MockSignValidator struct{}
-
-func (m *MockSignValidator) Validate(ctx context.Context, body []byte, header string, publicKeyBase64 string) error {
-	return nil
+type mockRouter struct {
+	definition.Router
+	err error
 }
 
-func (m *MockSignValidator) Close() error {
-	return nil
+type mockMiddleware struct {
+	definition.MiddlewareProvider
+	err error
 }
 
-type MockDecrypter struct{}
-
-func (m *MockDecrypter) Decrypt(ctx context.Context, data, key, iv string) (string, error) {
-	return "decrypted_data", nil
+type mockStep struct {
+	definition.Step
+	err error
 }
 
-func (m *MockDecrypter) Close() error {
-	return nil
+type mockCache struct {
+	definition.Cache
+	err error
 }
 
-type MockEncrypter struct{}
-
-func (m *MockEncrypter) Encrypt(ctx context.Context, data, key, iv string) (string, error) {
-	return "encrypted_data", nil
+type mockSigner struct {
+	definition.Signer
+	err error
 }
 
-func (m *MockEncrypter) Close() error {
-	return nil
+type mockEncrypter struct {
+	definition.Encrypter
+	err error
 }
 
-type MockPublisher struct{}
-
-func (m *MockPublisher) Publish(ctx context.Context, topic string, message []byte) error {
-	return nil
+type mockDecrypter struct {
+	definition.Decrypter
+	err error
 }
 
-func (m *MockPublisher) Close() error {
-	return nil
+type mockSignValidator struct {
+	definition.SignValidator
+	err error
 }
 
-// Mock providers for each plugin type
-type MockSignerProvider struct {
-	newFunc func(ctx context.Context, config map[string]string) (definition.Signer, func() error, error)
+type mockKeyManager struct {
+	definition.KeyManager
+	err error
 }
 
-func (m *MockSignerProvider) New(ctx context.Context, config map[string]string) (definition.Signer, func() error, error) {
-	if config == nil {
-		return nil, nil, errors.New("failed to load provider")
+// Mock providers
+type mockPublisherProvider struct {
+	publisher *mockPublisher
+	err       error
+}
+
+func (m *mockPublisherProvider) New(ctx context.Context, config map[string]string) (definition.Publisher, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
 	}
-	return m.newFunc(ctx, config)
+	return m.publisher, func() error { return nil }, nil
 }
 
-type MockSignValidatorProvider struct {
-	newFunc func(ctx context.Context, config map[string]string) (definition.SignValidator, func() error, error)
+type mockSchemaValidatorProvider struct {
+	validator *mockSchemaValidator
+	err       error
 }
 
-func (m *MockSignValidatorProvider) New(ctx context.Context, config map[string]string) (definition.SignValidator, func() error, error) {
-	return m.newFunc(ctx, config)
-}
-
-type MockDecrypterProvider struct {
-	newFunc func(ctx context.Context, config map[string]string) (definition.Decrypter, func() error, error)
-}
-
-func (m *MockDecrypterProvider) New(ctx context.Context, config map[string]string) (definition.Decrypter, func() error, error) {
-	return m.newFunc(ctx, config)
-}
-
-type MockEncrypterProvider struct {
-	newFunc func(ctx context.Context, config map[string]string) (definition.Encrypter, func() error, error)
-}
-
-func (m *MockEncrypterProvider) New(ctx context.Context, config map[string]string) (definition.Encrypter, func() error, error) {
-	return m.newFunc(ctx, config)
-}
-
-type MockPublisherProvider struct {
-	newFunc func(ctx context.Context, config map[string]string) (definition.Publisher, error)
-}
-
-func (m *MockPublisherProvider) New(ctx context.Context, config map[string]string) (definition.Publisher, error) {
-	return m.newFunc(ctx, config)
-}
-
-// MockStepProvider is a mock implementation of StepProvider
-type MockStepProvider struct {
-	newFunc func(ctx context.Context, config map[string]string) (definition.Step, func(), error)
-}
-
-func (m *MockStepProvider) New(ctx context.Context, config map[string]string) (definition.Step, func(), error) {
-	if m.newFunc != nil {
-		return m.newFunc(ctx, config)
+func (m *mockSchemaValidatorProvider) New(ctx context.Context, config map[string]string) (definition.SchemaValidator, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
 	}
-	return nil, nil, errors.New("new not implemented")
+	return m.validator, func() error { return nil }, nil
 }
 
-// TestNewManager tests the NewManager function
-func TestNewManager_Success(t *testing.T) {
+// Mock providers for additional interfaces
+type mockRouterProvider struct {
+	router *mockRouter
+	err    error
+}
+
+func (m *mockRouterProvider) New(ctx context.Context, config map[string]string) (definition.Router, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.router, func() error { return nil }, nil
+}
+
+type mockMiddlewareProvider struct {
+	provider *mockMiddleware
+	err      error
+}
+
+func (m *mockMiddlewareProvider) New(ctx context.Context, config map[string]string) (definition.MiddlewareProvider, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.provider, func() error { return nil }, nil
+}
+
+type mockStepProvider struct {
+	step *mockStep
+	err  error
+}
+
+func (m *mockStepProvider) New(ctx context.Context, config map[string]string) (definition.Step, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.step, func() error { return nil }, nil
+}
+
+// Mock providers for additional interfaces
+type mockCacheProvider struct {
+	cache *mockCache
+	err   error
+}
+
+func (m *mockCacheProvider) New(ctx context.Context, config map[string]string) (definition.Cache, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.cache, func() error { return nil }, nil
+}
+
+type mockSignerProvider struct {
+	signer *mockSigner
+	err    error
+}
+
+func (m *mockSignerProvider) New(ctx context.Context, config map[string]string) (definition.Signer, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.signer, func() error { return nil }, nil
+}
+
+type mockEncrypterProvider struct {
+	encrypter *mockEncrypter
+	err       error
+}
+
+func (m *mockEncrypterProvider) New(ctx context.Context, config map[string]string) (definition.Encrypter, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.encrypter, func() error { return nil }, nil
+}
+
+type mockDecrypterProvider struct {
+	decrypter *mockDecrypter
+	err       error
+}
+
+func (m *mockDecrypterProvider) New(ctx context.Context, config map[string]string) (definition.Decrypter, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.decrypter, func() error { return nil }, nil
+}
+
+type mockSignValidatorProvider struct {
+	validator *mockSignValidator
+	err       error
+}
+
+func (m *mockSignValidatorProvider) New(ctx context.Context, config map[string]string) (definition.SignValidator, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.validator, func() error { return nil }, nil
+}
+
+type mockKeyManagerProvider struct {
+	manager *mockKeyManager
+	err     error
+}
+
+func (m *mockKeyManagerProvider) New(ctx context.Context, config map[string]string) (definition.KeyManager, func() error, error) {
+	if m.err != nil {
+		return nil, nil, m.err
+	}
+	return m.manager, func() error { return nil }, nil
+}
+
+// Mock registry lookup for testing
+type mockRegistryLookup struct {
+	definition.RegistryLookup
+	err error
+}
+
+// testManager is a helper struct for testing
+type testManager struct {
+	*Manager
+	mockProviders map[string]interface{}
+	cleanup       func()
+}
+
+func newTestManager() *testManager {
 	// Create a temporary directory for testing
-	tmpDir, err := os.MkdirTemp("", "plugin-test-*")
-	require.NoError(t, err)
-	defer os.RemoveAll(tmpDir)
+	tmpDir, err := os.MkdirTemp("", "plugin-test")
+	if err != nil {
+		panic(fmt.Sprintf("failed to create temp dir: %v", err))
+	}
 
-	// Create a valid plugin directory
-	validPluginDir := filepath.Join(tmpDir, "plugins")
-	err = os.MkdirAll(validPluginDir, 0755)
-	require.NoError(t, err)
+	// Create a test manager with the temporary directory
+	ctx := context.Background()
+	cfg := &ManagerConfig{
+		Root:       tmpDir,
+		RemoteRoot: "",
+	}
+	m, cleanup, err := NewManager(ctx, cfg)
+	if err != nil {
+		panic(fmt.Sprintf("failed to create manager: %v", err))
+	}
 
+	tm := &testManager{
+		Manager:       m,
+		mockProviders: make(map[string]interface{}),
+		cleanup:       cleanup,
+	}
+
+	// Initialize the plugins map
+	m.plugins = make(map[string]*plugin.Plugin)
+
+	return tm
+}
+
+// Test cases
+func TestNewManager(t *testing.T) {
 	tests := []struct {
-		name        string
-		cfg         *ManagerConfig
-		wantErr     bool
-		errContains string
+		name    string
+		cfg     *ManagerConfig
+		wantErr bool
 	}{
 		{
-			name: "valid configuration",
+			name: "valid config",
 			cfg: &ManagerConfig{
-				Root:       validPluginDir,
+				Root:       t.TempDir(),
 				RemoteRoot: "",
 			},
 			wantErr: false,
 		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			manager, closer, err := NewManager(context.Background(), tt.cfg)
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, manager)
-				assert.Nil(t, closer)
-			} else {
-				assert.NoError(t, err)
-				assert.NotNil(t, manager)
-				assert.NotNil(t, closer)
-				if closer != nil {
-					closer()
-				}
-			}
-		})
-	}
-}
-
-// TestNewManager_Failure tests various failure scenarios for NewManager
-func TestNewManager_Failure(t *testing.T) {
-	// Create a temporary directory for testing
-	tmpDir, err := os.MkdirTemp("", "plugin-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tmpDir)
-
-	tests := []struct {
-		name        string
-		cfg         *ManagerConfig
-		wantErr     bool
-		errContains string
-	}{
 		{
-			name: "non-existent root path",
+			name: "invalid config",
 			cfg: &ManagerConfig{
-				Root: filepath.Join(tmpDir, "nonexistent"),
+				Root:       "/nonexistent/dir",
+				RemoteRoot: "",
 			},
-			wantErr:     true,
-			errContains: "no such file or directory",
-		},
-		{
-			name: "non-existent remote root",
-			cfg: &ManagerConfig{
-				Root:       tmpDir,
-				RemoteRoot: filepath.Join(tmpDir, "nonexistent.zip"),
-			},
-			wantErr:     true,
-			errContains: "no such file or directory",
-		},
-		{
-			name: "invalid remote root zip",
-			cfg: &ManagerConfig{
-				Root:       tmpDir,
-				RemoteRoot: filepath.Join(tmpDir, "invalid.zip"),
-			},
-			wantErr:     true,
-			errContains: "zip: not a valid zip file",
-		},
-	}
-
-	// Create an invalid zip file for testing
-	invalidZipPath := filepath.Join(tmpDir, "invalid.zip")
-	if err := os.WriteFile(invalidZipPath, []byte("not a zip file"), 0644); err != nil {
-		t.Fatalf("Failed to create invalid zip file: %v", err)
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			manager, cleanup, err := NewManager(context.Background(), tt.cfg)
-			if tt.wantErr {
-				if err == nil {
-					t.Error("Expected error, got nil")
-				} else if !contains(err.Error(), tt.errContains) {
-					t.Errorf("Expected error containing %q, got %q", tt.errContains, err.Error())
-				}
-				if manager != nil {
-					t.Error("Expected nil manager, got non-nil")
-				}
-				if cleanup != nil {
-					t.Error("Expected nil cleanup function, got non-nil")
-				}
-			} else {
-				if err != nil {
-					t.Errorf("Unexpected error: %v", err)
-				}
-				if manager == nil {
-					t.Error("Expected non-nil manager, got nil")
-				}
-				if cleanup == nil {
-					t.Error("Expected non-nil cleanup function, got nil")
-				}
-				if cleanup != nil {
-					cleanup()
-				}
-			}
-		})
-	}
-}
-
-// Helper function to check if a string contains a substring
-func contains(s, substr string) bool {
-	return strings.Contains(s, substr)
-}
-
-// TestProvider tests the provider function
-func TestProvider(t *testing.T) {
-	type testProvider struct {
-		value string
-	}
-
-	// Create a real plugin that exports a Provider symbol
-	pluginPath := filepath.Join(os.TempDir(), "test_provider.so")
-	defer os.Remove(pluginPath)
-
-	// Create a simple Go file that exports a Provider symbol
-	goFile := filepath.Join(os.TempDir(), "test_provider.go")
-	err := os.WriteFile(goFile, []byte(`
-package main
-
-type TestProvider struct {
-	value string
-}
-
-var Provider = &TestProvider{value: "test"}
-
-func main() {}
-`), 0644)
-	if err != nil {
-		t.Fatalf("Failed to create test plugin source: %v", err)
-	}
-	defer os.Remove(goFile)
-
-	// Build the plugin
-	cmd := exec.Command("go", "build", "-buildmode=plugin", "-o", pluginPath, goFile)
-	if err := cmd.Run(); err != nil {
-		t.Fatalf("Failed to build test plugin: %v", err)
-	}
-
-	// Load the plugin
-	p, err := plugin.Open(pluginPath)
-	if err != nil {
-		t.Fatalf("Failed to load test plugin: %v", err)
-	}
-
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		id          string
-		wantErr     bool
-		errContains string
-		verify      func(t *testing.T, got interface{})
-	}{
-		{
-			name: "success - valid provider",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": p,
-			},
-			id:      "test-provider",
-			wantErr: false,
-			verify: func(t *testing.T, got interface{}) {
-				provider, ok := got.(*testProvider)
-				assert.True(t, ok)
-				assert.Equal(t, "test", provider.value)
-			},
-		},
-		{
-			name:        "error - plugin not found",
-			plugins:     make(map[string]*plugin.Plugin),
-			id:          "nonexistent",
-			wantErr:     true,
-			errContains: "plugin nonexistent not found",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			id:          "test-provider",
-			wantErr:     true,
-			errContains: "failed to lookup Provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			id:          "test-provider",
-			wantErr:     true,
-			errContains: "failed to lookup Provider for test-provider",
-		},
-		{
-			name:        "error - empty plugin map",
-			plugins:     map[string]*plugin.Plugin{},
-			id:          "test-provider",
-			wantErr:     true,
-			errContains: "plugin test-provider not found",
+			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := provider[testProvider](tt.plugins, tt.id)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
+			ctx := context.Background()
+			_, cleanup, err := NewManager(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("NewManager() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
+			if cleanup != nil {
+				cleanup()
+			}
+		})
+	}
+}
 
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-			if tt.verify != nil {
-				tt.verify(t, got)
+func TestManager_Publisher(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockPublisherProvider
+		wantErr bool
+	}{
+		{
+			name: "successful publisher creation",
+			cfg: &Config{
+				ID:     "test-publisher",
+				Config: map[string]string{},
+			},
+			plugin: &mockPublisherProvider{
+				publisher: &mockPublisher{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-publisher",
+				Config: map[string]string{},
+			},
+			plugin: &mockPublisherProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			// Create a mock plugin that returns our provider
+			mockPlugin := &plugin.Plugin{}
+			tm.plugins[tt.cfg.ID] = mockPlugin
+
+			// Override the plugin lookup to return our mock provider
+			oldPlugins := tm.plugins
+			tm.plugins = make(map[string]*plugin.Plugin)
+			tm.plugins[tt.cfg.ID] = mockPlugin
+
+			_, err := tm.Publisher(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Publisher() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			// Restore the original plugins map
+			tm.plugins = oldPlugins
+		})
+	}
+}
+
+func TestManager_SchemaValidator(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockSchemaValidatorProvider
+		wantErr bool
+	}{
+		{
+			name: "successful validator creation",
+			cfg: &Config{
+				ID:     "test-validator",
+				Config: map[string]string{},
+			},
+			plugin: &mockSchemaValidatorProvider{
+				validator: &mockSchemaValidator{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-validator",
+				Config: map[string]string{},
+			},
+			plugin: &mockSchemaValidatorProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			// Create a mock plugin that returns our provider
+			mockPlugin := &plugin.Plugin{}
+			tm.plugins[tt.cfg.ID] = mockPlugin
+
+			_, err := tm.SchemaValidator(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.SchemaValidator() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Router(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockRouterProvider
+		wantErr bool
+	}{
+		{
+			name: "successful router creation",
+			cfg: &Config{
+				ID:     "test-router",
+				Config: map[string]string{},
+			},
+			plugin: &mockRouterProvider{
+				router: &mockRouter{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-router",
+				Config: map[string]string{},
+			},
+			plugin: &mockRouterProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Router(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Router() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Middleware(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockMiddlewareProvider
+		wantErr bool
+	}{
+		{
+			name: "successful middleware creation",
+			cfg: &Config{
+				ID:     "test-middleware",
+				Config: map[string]string{},
+			},
+			plugin: &mockMiddlewareProvider{
+				provider: &mockMiddleware{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-middleware",
+				Config: map[string]string{},
+			},
+			plugin: &mockMiddlewareProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Middleware(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Middleware() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Step(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockStepProvider
+		wantErr bool
+	}{
+		{
+			name: "successful step creation",
+			cfg: &Config{
+				ID:     "test-step",
+				Config: map[string]string{},
+			},
+			plugin: &mockStepProvider{
+				step: &mockStep{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-step",
+				Config: map[string]string{},
+			},
+			plugin: &mockStepProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Step(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Step() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Validator(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		wantErr bool
+	}{
+		{
+			name: "unimplemented validator",
+			cfg: &Config{
+				ID:     "test-validator",
+				Config: nil,
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			m := &Manager{
+				plugins: make(map[string]*plugin.Plugin),
+				closers: []func(){},
+			}
+
+			// We expect a panic from the unimplemented method
+			defer func() {
+				if r := recover(); r == nil {
+					t.Error("Expected panic from unimplemented Validator method")
+				}
+			}()
+
+			_, err := m.Validator(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Validator() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Cache(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockCacheProvider
+		wantErr bool
+	}{
+		{
+			name: "successful cache creation",
+			cfg: &Config{
+				ID:     "test-cache",
+				Config: map[string]string{},
+			},
+			plugin: &mockCacheProvider{
+				cache: &mockCache{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-cache",
+				Config: map[string]string{},
+			},
+			plugin: &mockCacheProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Cache(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Cache() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Signer(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockSignerProvider
+		wantErr bool
+	}{
+		{
+			name: "successful signer creation",
+			cfg: &Config{
+				ID:     "test-signer",
+				Config: map[string]string{},
+			},
+			plugin: &mockSignerProvider{
+				signer: &mockSigner{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-signer",
+				Config: map[string]string{},
+			},
+			plugin: &mockSignerProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Signer(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Signer() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Encryptor(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockEncrypterProvider
+		wantErr bool
+	}{
+		{
+			name: "successful encrypter creation",
+			cfg: &Config{
+				ID:     "test-encrypter",
+				Config: map[string]string{},
+			},
+			plugin: &mockEncrypterProvider{
+				encrypter: &mockEncrypter{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-encrypter",
+				Config: map[string]string{},
+			},
+			plugin: &mockEncrypterProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Encryptor(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Encryptor() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_Decryptor(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockDecrypterProvider
+		wantErr bool
+	}{
+		{
+			name: "successful decrypter creation",
+			cfg: &Config{
+				ID:     "test-decrypter",
+				Config: map[string]string{},
+			},
+			plugin: &mockDecrypterProvider{
+				decrypter: &mockDecrypter{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-decrypter",
+				Config: map[string]string{},
+			},
+			plugin: &mockDecrypterProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.Decryptor(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.Decryptor() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_SignValidator(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockSignValidatorProvider
+		wantErr bool
+	}{
+		{
+			name: "successful sign validator creation",
+			cfg: &Config{
+				ID:     "test-sign-validator",
+				Config: map[string]string{},
+			},
+			plugin: &mockSignValidatorProvider{
+				validator: &mockSignValidator{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-sign-validator",
+				Config: map[string]string{},
+			},
+			plugin: &mockSignValidatorProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			_, err := tm.SignValidator(ctx, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.SignValidator() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestManager_KeyManager(t *testing.T) {
+	tests := []struct {
+		name    string
+		cfg     *Config
+		plugin  *mockKeyManagerProvider
+		wantErr bool
+	}{
+		{
+			name: "successful key manager creation",
+			cfg: &Config{
+				ID:     "test-key-manager",
+				Config: map[string]string{},
+			},
+			plugin: &mockKeyManagerProvider{
+				manager: &mockKeyManager{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "provider error",
+			cfg: &Config{
+				ID:     "test-key-manager",
+				Config: map[string]string{},
+			},
+			plugin: &mockKeyManagerProvider{
+				err: errors.New("provider error"),
+			},
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+			tm := newTestManager()
+			tm.mockProviders[tt.cfg.ID] = tt.plugin
+
+			// Create mock cache and registry lookup
+			mockCache := &mockCache{}
+			mockRegistry := &mockRegistryLookup{}
+
+			_, err := tm.KeyManager(ctx, mockCache, mockRegistry, tt.cfg)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Manager.KeyManager() error = %v, wantErr %v", err, tt.wantErr)
 			}
 		})
 	}
 }
 
 func TestUnzip(t *testing.T) {
-	// Create a temporary directory for testing
-	tempDir, err := os.MkdirTemp("", "unzip-test-*")
-	if err != nil {
-		t.Fatalf("Failed to create temp dir: %v", err)
-	}
-	defer os.RemoveAll(tempDir)
-
-	// Create test cases
 	tests := []struct {
-		name          string
-		setup         func() (string, string, error)
-		wantErr       bool
-		validateFiles func(string) error
+		name    string
+		src     string
+		dest    string
+		wantErr bool
+		setup   func() (string, string, func())
 	}{
 		{
-			name: "successful unzip with single file",
-			setup: func() (string, string, error) {
-				// Create a temporary zip file
-				zipPath := filepath.Join(tempDir, "test.zip")
-				zipFile, err := os.Create(zipPath)
+			name: "successful unzip",
+			setup: func() (string, string, func()) {
+				// Create a temporary directory for the test
+				tmpDir, err := os.MkdirTemp("", "unzip-test")
 				if err != nil {
-					return "", "", err
+					t.Fatalf("failed to create temp dir: %v", err)
 				}
-				defer zipFile.Close()
+
+				// Create a temporary zip file
+				zipFile := filepath.Join(tmpDir, "test.zip")
+				f, err := os.Create(zipFile)
+				if err != nil {
+					t.Fatalf("failed to create zip file: %v", err)
+				}
+				defer f.Close()
 
 				// Create a zip writer
-				zipWriter := zip.NewWriter(zipFile)
+				zipWriter := zip.NewWriter(f)
 				defer zipWriter.Close()
 
 				// Add a file to the zip
-				fileInZip, err := zipWriter.Create("test.txt")
+				fileWriter, err := zipWriter.Create("test.txt")
 				if err != nil {
-					return "", "", err
+					t.Fatalf("failed to create file in zip: %v", err)
+				}
+				_, err = fileWriter.Write([]byte("test content"))
+				if err != nil {
+					t.Fatalf("failed to write to zip file: %v", err)
 				}
-				fileInZip.Write([]byte("test content"))
 
-				return zipPath, filepath.Join(tempDir, "output"), nil
+				// Create a destination directory
+				destDir := filepath.Join(tmpDir, "dest")
+				if err := os.MkdirAll(destDir, 0755); err != nil {
+					t.Fatalf("failed to create dest dir: %v", err)
+				}
+
+				return zipFile, destDir, func() {
+					os.RemoveAll(tmpDir)
+				}
 			},
 			wantErr: false,
-			validateFiles: func(dest string) error {
-				// Check if the file was extracted
-				extractedFile := filepath.Join(dest, "test.txt")
-				if _, err := os.Stat(extractedFile); err != nil {
-					return err
-				}
-				return nil
-			},
 		},
 		{
-			name: "successful unzip with nested directories",
-			setup: func() (string, string, error) {
-				// Create a temporary zip file
-				zipPath := filepath.Join(tempDir, "nested.zip")
-				zipFile, err := os.Create(zipPath)
+			name: "nonexistent source file",
+			setup: func() (string, string, func()) {
+				tmpDir, err := os.MkdirTemp("", "unzip-test")
 				if err != nil {
-					return "", "", err
+					t.Fatalf("failed to create temp dir: %v", err)
 				}
-				defer zipFile.Close()
-
-				// Create a zip writer
-				zipWriter := zip.NewWriter(zipFile)
-				defer zipWriter.Close()
-
-				// Add a file in a nested directory
-				fileInZip, err := zipWriter.Create("nested/test.txt")
-				if err != nil {
-					return "", "", err
+				destDir := filepath.Join(tmpDir, "dest")
+				if err := os.MkdirAll(destDir, 0755); err != nil {
+					t.Fatalf("failed to create dest dir: %v", err)
 				}
-				fileInZip.Write([]byte("nested content"))
-
-				return zipPath, filepath.Join(tempDir, "nested-output"), nil
-			},
-			wantErr: false,
-			validateFiles: func(dest string) error {
-				// Check if the nested file was extracted
-				extractedFile := filepath.Join(dest, "nested", "test.txt")
-				if _, err := os.Stat(extractedFile); err != nil {
-					return err
+				return "nonexistent.zip", destDir, func() {
+					os.RemoveAll(tmpDir)
 				}
-				return nil
-			},
-		},
-		{
-			name: "non-existent zip file",
-			setup: func() (string, string, error) {
-				return "non-existent.zip", filepath.Join(tempDir, "output"), nil
 			},
 			wantErr: true,
-			validateFiles: func(dest string) error {
-				return nil
-			},
 		},
 		{
 			name: "invalid zip file",
-			setup: func() (string, string, error) {
+			setup: func() (string, string, func()) {
+				tmpDir, err := os.MkdirTemp("", "unzip-test")
+				if err != nil {
+					t.Fatalf("failed to create temp dir: %v", err)
+				}
+
 				// Create an invalid zip file
-				zipPath := filepath.Join(tempDir, "invalid.zip")
-				if err := os.WriteFile(zipPath, []byte("not a zip file"), 0644); err != nil {
-					return "", "", err
-				}
-				return zipPath, filepath.Join(tempDir, "output"), nil
-			},
-			wantErr: true,
-			validateFiles: func(dest string) error {
-				return nil
-			},
-		},
-		{
-			name: "destination directory creation failure",
-			setup: func() (string, string, error) {
-				// Create a temporary zip file
-				zipPath := filepath.Join(tempDir, "test.zip")
-				zipFile, err := os.Create(zipPath)
+				zipFile := filepath.Join(tmpDir, "test.zip")
+				f, err := os.Create(zipFile)
 				if err != nil {
-					return "", "", err
+					t.Fatalf("failed to create zip file: %v", err)
 				}
-				defer zipFile.Close()
+				defer f.Close()
 
-				// Create a zip writer
-				zipWriter := zip.NewWriter(zipFile)
-				defer zipWriter.Close()
-
-				// Add a file to the zip
-				fileInZip, err := zipWriter.Create("test.txt")
+				// Write invalid content
+				_, err = f.Write([]byte("invalid zip content"))
 				if err != nil {
-					return "", "", err
+					t.Fatalf("failed to write to zip file: %v", err)
 				}
-				fileInZip.Write([]byte("test content"))
-
-				// Create a read-only directory
-				readOnlyDir := filepath.Join(tempDir, "readonly")
-				if err := os.MkdirAll(readOnlyDir, 0444); err != nil {
-					return "", "", err
-				}
-
-				return zipPath, readOnlyDir, nil
-			},
-			wantErr: true,
-			validateFiles: func(dest string) error {
-				return nil
-			},
-		},
-		{
-			name: "file copy failure",
-			setup: func() (string, string, error) {
-				// Create a temporary zip file
-				zipPath := filepath.Join(tempDir, "test.zip")
-				zipFile, err := os.Create(zipPath)
-				if err != nil {
-					return "", "", err
-				}
-				defer zipFile.Close()
-
-				// Create a zip writer
-				zipWriter := zip.NewWriter(zipFile)
-				defer zipWriter.Close()
-
-				// Add a file to the zip
-				fileInZip, err := zipWriter.Create("test.txt")
-				if err != nil {
-					return "", "", err
-				}
-				fileInZip.Write([]byte("test content"))
-
-				// Create a destination directory with a file that can't be overwritten
-				destDir := filepath.Join(tempDir, "dest")
-				if err := os.MkdirAll(destDir, 0755); err != nil {
-					return "", "", err
-				}
-				// Create a read-only file in the destination
-				readOnlyFile := filepath.Join(destDir, "test.txt")
-				if err := os.WriteFile(readOnlyFile, []byte("readonly"), 0444); err != nil {
-					return "", "", err
-				}
-
-				return zipPath, destDir, nil
-			},
-			wantErr: true,
-			validateFiles: func(dest string) error {
-				return nil
-			},
-		},
-		{
-			name: "file copy error due to read-only destination",
-			setup: func() (string, string, error) {
-				// Create a temporary zip file
-				zipPath := filepath.Join(tempDir, "test.zip")
-				zipFile, err := os.Create(zipPath)
-				if err != nil {
-					return "", "", err
-				}
-				defer zipFile.Close()
-
-				// Create a zip writer
-				zipWriter := zip.NewWriter(zipFile)
-				defer zipWriter.Close()
-
-				// Add a file to the zip
-				fileInZip, err := zipWriter.Create("test.txt")
-				if err != nil {
-					return "", "", err
-				}
-				fileInZip.Write([]byte("test content"))
-
-				// Create a read-only destination directory
-				destDir := filepath.Join(tempDir, "readonly-dest")
-				if err := os.MkdirAll(destDir, 0444); err != nil {
-					return "", "", err
-				}
-
-				return zipPath, destDir, nil
-			},
-			wantErr: true,
-			validateFiles: func(dest string) error {
-				return nil
-			},
-		},
-		{
-			name: "file copy error due to invalid source file",
-			setup: func() (string, string, error) {
-				// Create a temporary zip file
-				zipPath := filepath.Join(tempDir, "test.zip")
-				zipFile, err := os.Create(zipPath)
-				if err != nil {
-					return "", "", err
-				}
-				defer zipFile.Close()
-
-				// Create a zip writer
-				zipWriter := zip.NewWriter(zipFile)
-				defer zipWriter.Close()
-
-				// Add a file to the zip with invalid content
-				fileInZip, err := zipWriter.Create("test.txt")
-				if err != nil {
-					return "", "", err
-				}
-				// Write some content that will cause an error during extraction
-				fileInZip.Write([]byte("test content"))
 
 				// Create a destination directory
-				destDir := filepath.Join(tempDir, "dest")
+				destDir := filepath.Join(tmpDir, "dest")
 				if err := os.MkdirAll(destDir, 0755); err != nil {
-					return "", "", err
+					t.Fatalf("failed to create dest dir: %v", err)
 				}
 
-				// Close the zip file to ensure it's written
-				if err := zipWriter.Close(); err != nil {
-					return "", "", err
+				return zipFile, destDir, func() {
+					os.RemoveAll(tmpDir)
 				}
-				if err := zipFile.Close(); err != nil {
-					return "", "", err
-				}
-
-				// Corrupt the zip file
-				if err := os.WriteFile(zipPath, []byte("corrupted content"), 0644); err != nil {
-					return "", "", err
-				}
-
-				return zipPath, destDir, nil
 			},
 			wantErr: true,
-			validateFiles: func(dest string) error {
-				return nil
-			},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			src, dest, err := tt.setup()
-			if err != nil {
-				t.Fatalf("Setup failed: %v", err)
-			}
+			src, dest, cleanup := tt.setup()
+			defer cleanup()
 
-			err = unzip(src, dest)
+			err := unzip(src, dest)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("unzip() error = %v, wantErr %v", err, tt.wantErr)
-				return
 			}
 
 			if !tt.wantErr {
-				if err := tt.validateFiles(dest); err != nil {
-					t.Errorf("File validation failed: %v", err)
+				// Verify that the file was extracted
+				extractedFile := filepath.Join(dest, "test.txt")
+				if _, err := os.Stat(extractedFile); os.IsNotExist(err) {
+					t.Errorf("unzip() did not extract file to %s", extractedFile)
 				}
 			}
 		})
 	}
 }
-
-func TestValidator(t *testing.T) {
-	tests := []struct {
-		name      string
-		cfg       *Config
-		plugins   map[string]*plugin.Plugin
-		wantPanic bool
-		panicMsg  string
-	}{
-		{
-			name: "unimplemented panic",
-			cfg: &Config{
-				ID:     "test-validator",
-				Config: map[string]string{},
-			},
-			plugins:   make(map[string]*plugin.Plugin),
-			wantPanic: true,
-			panicMsg:  "unimplemented",
-		},
-		{
-			name: "nil config",
-			cfg:  nil,
-			plugins: map[string]*plugin.Plugin{
-				"test-validator": &plugin.Plugin{},
-			},
-			wantPanic: true,
-			panicMsg:  "unimplemented",
-		},
-		{
-			name: "empty config panic",
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			plugins: map[string]*plugin.Plugin{
-				"test-validator": &plugin.Plugin{},
-			},
-			wantPanic: true,
-			panicMsg:  "unimplemented",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			if tt.wantPanic {
-				defer func() {
-					if r := recover(); r == nil {
-						t.Error("Expected panic, got none")
-					} else if !contains(fmt.Sprint(r), tt.panicMsg) {
-						t.Errorf("Expected panic containing %q, got %q", tt.panicMsg, r)
-					}
-				}()
-			}
-
-			got, err := m.Validator(context.Background(), tt.cfg)
-			if !tt.wantPanic {
-				if err != nil {
-					t.Errorf("Unexpected error: %v", err)
-				}
-				if got == nil {
-					t.Error("Expected non-nil validator, got nil")
-				}
-			}
-		})
-	}
-}
-
-// MockKeyManager is a mock implementation of KeyManager
-type MockKeyManager struct{}
-
-func (m *MockKeyManager) GetPublicKey(ctx context.Context, subscriberId string) (string, error) {
-	return "mock_public_key", nil
-}
-
-func (m *MockKeyManager) DeletePrivateKeys(ctx context.Context, subscriberId string) error {
-	return nil
-}
-
-func (m *MockKeyManager) Close() error {
-	return nil
-}
-
-func (m *MockKeyManager) GenerateKeyPairs() (*model.Keyset, error) {
-	return &model.Keyset{
-		UniqueKeyID:    "mock_key_id",
-		SigningPrivate: "mock_signing_private",
-		SigningPublic:  "mock_signing_public",
-		EncrPrivate:    "mock_encr_private",
-		EncrPublic:     "mock_encr_public",
-	}, nil
-}
-
-func (m *MockKeyManager) StorePrivateKeys(ctx context.Context, keyID string, keys *model.Keyset) error {
-	return nil
-}
-
-func (m *MockKeyManager) SigningPrivateKey(ctx context.Context, keyID string) (string, string, error) {
-	return "mock_signing_private", "mock_iv", nil
-}
-
-func (m *MockKeyManager) EncrPrivateKey(ctx context.Context, keyID string) (string, string, error) {
-	return "mock_encr_private", "mock_iv", nil
-}
-
-func (m *MockKeyManager) SigningPublicKey(ctx context.Context, subscriberID, uniqueKeyID string) (string, error) {
-	return "mock_signing_public", nil
-}
-
-func (m *MockKeyManager) EncrPublicKey(ctx context.Context, subscriberID, uniqueKeyID string) (string, error) {
-	return "mock_encr_public", nil
-}
-
-// MockKeyManagerProvider is a mock implementation of KeyManagerProvider
-type MockKeyManagerProvider struct {
-	newFunc func(ctx context.Context, cache definition.Cache, rClient definition.RegistryLookup, config map[string]string) (definition.KeyManager, func() error, error)
-}
-
-func (m *MockKeyManagerProvider) New(ctx context.Context, cache definition.Cache, rClient definition.RegistryLookup, config map[string]string) (definition.KeyManager, func() error, error) {
-	if config == nil {
-		return nil, nil, errors.New("config cannot be nil")
-	}
-	return m.newFunc(ctx, cache, rClient, config)
-}
-
-// MockCache is a mock implementation of Cache
-type MockCache struct{}
-
-func (m *MockCache) Get(ctx context.Context, key string) (string, error) {
-	return "", nil
-}
-
-func (m *MockCache) Set(ctx context.Context, key string, value string, ttl time.Duration) error {
-	return nil
-}
-
-func (m *MockCache) Delete(ctx context.Context, key string) error {
-	return nil
-}
-
-func (m *MockCache) Clear(ctx context.Context) error {
-	return nil
-}
-
-func (m *MockCache) Close() error {
-	return nil
-}
-
-// MockRegistryLookup is a mock implementation of RegistryLookup
-type MockRegistryLookup struct{}
-
-func (m *MockRegistryLookup) LookupRegistry(ctx context.Context, subscriberId string) (string, error) {
-	return "mock_registry", nil
-}
-
-func (m *MockRegistryLookup) Lookup(ctx context.Context, subscription *model.Subscription) ([]model.Subscription, error) {
-	return []model.Subscription{}, nil
-}
-
-// MockPlugin is a mock implementation of plugin.Plugin
-type MockPlugin struct {
-	lookupFunc func(symName string) (plugin.Symbol, error)
-}
-
-func (m *MockPlugin) Lookup(symName string) (plugin.Symbol, error) {
-	return m.lookupFunc(symName)
-}
-
-func TestKeyManager(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		cache       definition.Cache
-		rClient     definition.RegistryLookup
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			cache:       &MockCache{},
-			rClient:     &MockRegistryLookup{},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			cache:       &MockCache{},
-			rClient:     &MockRegistryLookup{},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			cache:       &MockCache{},
-			rClient:     &MockRegistryLookup{},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			cache:       &MockCache{},
-			rClient:     &MockRegistryLookup{},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			cache:       &MockCache{},
-			rClient:     &MockRegistryLookup{},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.KeyManager(context.Background(), tt.cache, tt.rClient, tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestPublisher(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Publisher(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestSchemaValidator(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.SchemaValidator(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestRouter(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Router(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestMiddleware(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Middleware(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestStep(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Step(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestCache(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Cache(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestSigner(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Signer(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestEncryptor(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Encryptor(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestDecryptor(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.Decryptor(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}
-
-func TestSignValidator(t *testing.T) {
-	tests := []struct {
-		name        string
-		plugins     map[string]*plugin.Plugin
-		cfg         *Config
-		wantErr     bool
-		errContains string
-	}{
-		{
-			name:        "error - nil config",
-			plugins:     make(map[string]*plugin.Plugin),
-			cfg:         nil,
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - empty config",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "",
-				Config: nil,
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for",
-		},
-		{
-			name:    "error - plugin not found",
-			plugins: make(map[string]*plugin.Plugin),
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - provider lookup failed",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": &plugin.Plugin{},
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-		{
-			name: "error - nil plugin",
-			plugins: map[string]*plugin.Plugin{
-				"test-provider": nil,
-			},
-			cfg: &Config{
-				ID:     "test-provider",
-				Config: map[string]string{},
-			},
-			wantErr:     true,
-			errContains: "failed to load provider for test-provider",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := &Manager{
-				plugins: tt.plugins,
-				closers: make([]func(), 0),
-			}
-
-			got, err := m.SignValidator(context.Background(), tt.cfg)
-
-			if tt.wantErr {
-				assert.Error(t, err)
-				assert.Contains(t, err.Error(), tt.errContains)
-				assert.Nil(t, got)
-				return
-			}
-
-			assert.NoError(t, err)
-			assert.NotNil(t, got)
-		})
-	}
-}