936 lines
21 KiB
Go
936 lines
21 KiB
Go
package plugin
|
|
|
|
import (
|
|
"archive/zip"
|
|
"context"
|
|
// "errors"
|
|
// "fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"plugin"
|
|
"testing"
|
|
|
|
"github.com/beckn/beckn-onix/pkg/plugin/definition"
|
|
)
|
|
|
|
type mockPlugin struct {
|
|
symbol plugin.Symbol
|
|
err error
|
|
}
|
|
|
|
func (m *mockPlugin) Lookup(str string) (plugin.Symbol, error) {
|
|
return m.symbol, m.err
|
|
}
|
|
|
|
// Mock implementations for testing
|
|
type mockPublisher struct {
|
|
definition.Publisher
|
|
}
|
|
|
|
type mockSchemaValidator struct {
|
|
definition.SchemaValidator
|
|
}
|
|
|
|
type mockRouter struct {
|
|
definition.Router
|
|
}
|
|
|
|
type mockMiddleware struct {
|
|
definition.MiddlewareProvider
|
|
}
|
|
|
|
type mockStep struct {
|
|
definition.Step
|
|
}
|
|
|
|
type mockCache struct {
|
|
definition.Cache
|
|
}
|
|
|
|
type mockSigner struct {
|
|
definition.Signer
|
|
}
|
|
|
|
type mockEncrypter struct {
|
|
definition.Encrypter
|
|
}
|
|
|
|
type mockDecrypter struct {
|
|
definition.Decrypter
|
|
}
|
|
|
|
type mockSignValidator struct {
|
|
definition.SignValidator
|
|
}
|
|
|
|
type mockKeyManager struct {
|
|
definition.KeyManager
|
|
}
|
|
|
|
// Mock providers
|
|
type mockPublisherProvider struct {
|
|
publisher definition.Publisher
|
|
err error
|
|
errFunc func() error
|
|
}
|
|
|
|
func (m *mockPublisherProvider) New(ctx context.Context, config map[string]string) (definition.Publisher, func() error, error) {
|
|
return m.publisher, m.errFunc, m.err
|
|
}
|
|
|
|
type mockSchemaValidatorProvider struct {
|
|
validator *mockSchemaValidator
|
|
err error
|
|
}
|
|
|
|
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 m.validator, func() error { return nil }, nil
|
|
}
|
|
|
|
// 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")
|
|
// if err != nil {
|
|
// panic(fmt.Sprintf("failed to create temp dir: %v", 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
|
|
}{
|
|
{
|
|
name: "valid config",
|
|
cfg: &ManagerConfig{
|
|
Root: t.TempDir(),
|
|
RemoteRoot: "",
|
|
},
|
|
wantErr: false,
|
|
},
|
|
{
|
|
name: "invalid config",
|
|
cfg: &ManagerConfig{
|
|
Root: "/nonexistent/dir",
|
|
RemoteRoot: "",
|
|
},
|
|
wantErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
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()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPublisherSuccess(t *testing.T) {
|
|
publisherID := "publisherId"
|
|
errFunc := func() error { return nil}
|
|
mockPublisher := &mockPublisher{}
|
|
m := &Manager{
|
|
closers: []func(){},
|
|
plugins: map[string]onixPlugin{
|
|
publisherID: &mockPlugin{
|
|
symbol : &mockPublisherProvider{
|
|
publisher: mockPublisher,
|
|
err: errFunc(),
|
|
},
|
|
},
|
|
}}
|
|
p, err := m.Publisher(context.Background(), &Config{
|
|
ID: publisherID,
|
|
Config: map[string]string{},
|
|
});
|
|
if(err != nil) {
|
|
t.Errorf("Manager.Publisher() error = %v", err)
|
|
}
|
|
// if(len(m.closers) == 0) {
|
|
// t.Errorf("Manager.Publisher() did not register closer")
|
|
// }
|
|
if p != mockPublisher {
|
|
t.Errorf("Manager.Publisher() did not return the correct publisher")
|
|
}
|
|
}
|
|
|
|
// 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) {
|
|
tests := []struct {
|
|
name string
|
|
src string
|
|
dest string
|
|
wantErr bool
|
|
setup func() (string, string, func())
|
|
}{
|
|
{
|
|
name: "successful unzip",
|
|
setup: func() (string, string, func()) {
|
|
// Create a temporary directory for the test
|
|
tmpDir, err := os.MkdirTemp("", "unzip-test")
|
|
if err != nil {
|
|
t.Fatalf("failed to create temp dir: %v", err)
|
|
}
|
|
|
|
// 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(f)
|
|
defer zipWriter.Close()
|
|
|
|
// Add a file to the zip
|
|
fileWriter, err := zipWriter.Create("test.txt")
|
|
if err != nil {
|
|
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)
|
|
}
|
|
|
|
// 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,
|
|
},
|
|
{
|
|
name: "nonexistent source file",
|
|
setup: func() (string, string, func()) {
|
|
tmpDir, err := os.MkdirTemp("", "unzip-test")
|
|
if err != nil {
|
|
t.Fatalf("failed to create temp dir: %v", err)
|
|
}
|
|
destDir := filepath.Join(tmpDir, "dest")
|
|
if err := os.MkdirAll(destDir, 0755); err != nil {
|
|
t.Fatalf("failed to create dest dir: %v", err)
|
|
}
|
|
return "nonexistent.zip", destDir, func() {
|
|
os.RemoveAll(tmpDir)
|
|
}
|
|
},
|
|
wantErr: true,
|
|
},
|
|
{
|
|
name: "invalid zip file",
|
|
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
|
|
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()
|
|
|
|
// Write invalid content
|
|
_, err = f.Write([]byte("invalid zip content"))
|
|
if err != nil {
|
|
t.Fatalf("failed to write to zip file: %v", err)
|
|
}
|
|
|
|
// 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: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
src, dest, cleanup := tt.setup()
|
|
defer cleanup()
|
|
|
|
err := unzip(src, dest)
|
|
if (err != nil) != tt.wantErr {
|
|
t.Errorf("unzip() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
|
|
if !tt.wantErr {
|
|
// 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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|