mirror of
https://github.com/lukaszraczylo/gohoarder.git
synced 2026-06-10 23:29:22 +00:00
Initial commit
This commit is contained in:
Vendored
+980
@@ -0,0 +1,980 @@
|
||||
package cache
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/lukaszraczylo/gohoarder/pkg/metadata"
|
||||
"github.com/lukaszraczylo/gohoarder/pkg/storage"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
// MockStorageBackend is a mock for storage.StorageBackend
|
||||
type MockStorageBackend struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Get(ctx context.Context, key string) (io.ReadCloser, error) {
|
||||
args := m.Called(ctx, key)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(io.ReadCloser), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Put(ctx context.Context, key string, data io.Reader, opts *storage.PutOptions) error {
|
||||
args := m.Called(ctx, key, data, opts)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Delete(ctx context.Context, key string) error {
|
||||
args := m.Called(ctx, key)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Exists(ctx context.Context, key string) (bool, error) {
|
||||
args := m.Called(ctx, key)
|
||||
return args.Bool(0), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) List(ctx context.Context, prefix string, opts *storage.ListOptions) ([]storage.StorageObject, error) {
|
||||
args := m.Called(ctx, prefix, opts)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).([]storage.StorageObject), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Stat(ctx context.Context, key string) (*storage.StorageInfo, error) {
|
||||
args := m.Called(ctx, key)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*storage.StorageInfo), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) GetQuota(ctx context.Context) (*storage.QuotaInfo, error) {
|
||||
args := m.Called(ctx)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*storage.QuotaInfo), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Health(ctx context.Context) error {
|
||||
args := m.Called(ctx)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockStorageBackend) Close() error {
|
||||
args := m.Called()
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
// MockMetadataStore is a mock for metadata.MetadataStore
|
||||
type MockMetadataStore struct {
|
||||
mock.Mock
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) SavePackage(ctx context.Context, pkg *metadata.Package) error {
|
||||
args := m.Called(ctx, pkg)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) GetPackage(ctx context.Context, registry, name, version string) (*metadata.Package, error) {
|
||||
args := m.Called(ctx, registry, name, version)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*metadata.Package), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) DeletePackage(ctx context.Context, registry, name, version string) error {
|
||||
args := m.Called(ctx, registry, name, version)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) ListPackages(ctx context.Context, opts *metadata.ListOptions) ([]*metadata.Package, error) {
|
||||
args := m.Called(ctx, opts)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).([]*metadata.Package), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) UpdateDownloadCount(ctx context.Context, registry, name, version string) error {
|
||||
args := m.Called(ctx, registry, name, version)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) GetStats(ctx context.Context, registry string) (*metadata.Stats, error) {
|
||||
args := m.Called(ctx, registry)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*metadata.Stats), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) SaveScanResult(ctx context.Context, result *metadata.ScanResult) error {
|
||||
args := m.Called(ctx, result)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) GetScanResult(ctx context.Context, registry, name, version string) (*metadata.ScanResult, error) {
|
||||
args := m.Called(ctx, registry, name, version)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*metadata.ScanResult), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) Count(ctx context.Context) (int, error) {
|
||||
args := m.Called(ctx)
|
||||
return args.Int(0), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) Health(ctx context.Context) error {
|
||||
args := m.Called(ctx)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) Close() error {
|
||||
args := m.Called()
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) SaveCVEBypass(ctx context.Context, bypass *metadata.CVEBypass) error {
|
||||
args := m.Called(ctx, bypass)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) GetActiveCVEBypasses(ctx context.Context) ([]*metadata.CVEBypass, error) {
|
||||
args := m.Called(ctx)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).([]*metadata.CVEBypass), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) ListCVEBypasses(ctx context.Context, opts *metadata.BypassListOptions) ([]*metadata.CVEBypass, error) {
|
||||
args := m.Called(ctx, opts)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).([]*metadata.CVEBypass), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) DeleteCVEBypass(ctx context.Context, id string) error {
|
||||
args := m.Called(ctx, id)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) CleanupExpiredBypasses(ctx context.Context) (int, error) {
|
||||
args := m.Called(ctx)
|
||||
return args.Int(0), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) GetTimeSeriesStats(ctx context.Context, period string, registry string) (*metadata.TimeSeriesStats, error) {
|
||||
args := m.Called(ctx, period, registry)
|
||||
if args.Get(0) == nil {
|
||||
return nil, args.Error(1)
|
||||
}
|
||||
return args.Get(0).(*metadata.TimeSeriesStats), args.Error(1)
|
||||
}
|
||||
|
||||
func (m *MockMetadataStore) AggregateDownloadData(ctx context.Context) error {
|
||||
args := m.Called(ctx)
|
||||
return args.Error(0)
|
||||
}
|
||||
|
||||
// TestNew tests cache manager creation
|
||||
func TestNew(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
storage storage.StorageBackend
|
||||
metadata metadata.MetadataStore
|
||||
config Config
|
||||
wantErr bool
|
||||
errContains string
|
||||
}{
|
||||
// GOOD: Valid configuration
|
||||
{
|
||||
name: "valid config with defaults",
|
||||
storage: &MockStorageBackend{},
|
||||
metadata: &MockMetadataStore{},
|
||||
config: Config{},
|
||||
wantErr: false,
|
||||
},
|
||||
{
|
||||
name: "valid config with custom settings",
|
||||
storage: &MockStorageBackend{},
|
||||
metadata: &MockMetadataStore{},
|
||||
config: Config{
|
||||
DefaultTTL: 24 * time.Hour,
|
||||
CleanupInterval: 30 * time.Minute,
|
||||
EvictionThreshold: 0.8,
|
||||
MaxConcurrent: 50,
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
// WRONG: Missing required components
|
||||
{
|
||||
name: "nil storage",
|
||||
storage: nil,
|
||||
metadata: &MockMetadataStore{},
|
||||
config: Config{},
|
||||
wantErr: true,
|
||||
errContains: "storage backend is required",
|
||||
},
|
||||
{
|
||||
name: "nil metadata",
|
||||
storage: &MockStorageBackend{},
|
||||
metadata: nil,
|
||||
config: Config{},
|
||||
wantErr: true,
|
||||
errContains: "metadata store is required",
|
||||
},
|
||||
// EDGE: Both nil
|
||||
{
|
||||
name: "both nil",
|
||||
storage: nil,
|
||||
metadata: nil,
|
||||
config: Config{},
|
||||
wantErr: true,
|
||||
errContains: "storage backend is required",
|
||||
},
|
||||
// EDGE: Zero values get defaults
|
||||
{
|
||||
name: "zero config gets defaults",
|
||||
storage: &MockStorageBackend{},
|
||||
metadata: &MockMetadataStore{},
|
||||
config: Config{},
|
||||
wantErr: false,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
manager, err := New(tt.storage, tt.metadata, nil, tt.config)
|
||||
|
||||
if tt.wantErr {
|
||||
require.Error(t, err)
|
||||
if tt.errContains != "" {
|
||||
assert.Contains(t, err.Error(), tt.errContains)
|
||||
}
|
||||
assert.Nil(t, manager)
|
||||
} else {
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, manager)
|
||||
|
||||
// Verify defaults were set
|
||||
if tt.config.DefaultTTL == 0 {
|
||||
assert.Equal(t, 7*24*time.Hour, manager.config.DefaultTTL)
|
||||
}
|
||||
if tt.config.CleanupInterval == 0 {
|
||||
assert.Equal(t, 1*time.Hour, manager.config.CleanupInterval)
|
||||
}
|
||||
if tt.config.EvictionThreshold == 0 {
|
||||
assert.Equal(t, 0.9, manager.config.EvictionThreshold)
|
||||
}
|
||||
if tt.config.MaxConcurrent == 0 {
|
||||
assert.Equal(t, 100, manager.config.MaxConcurrent)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGet tests cache retrieval with various scenarios
|
||||
func TestGet(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
registry string
|
||||
packageName string
|
||||
version string
|
||||
setupMock func(*MockStorageBackend, *MockMetadataStore)
|
||||
fetchFunc func(context.Context) (io.ReadCloser, string, error)
|
||||
wantFromCache bool
|
||||
wantErr bool
|
||||
errContains string
|
||||
}{
|
||||
// GOOD: Cache hit
|
||||
{
|
||||
name: "cache hit - package exists and valid",
|
||||
registry: "npm",
|
||||
packageName: "react",
|
||||
version: "18.2.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
now := time.Now()
|
||||
expiresAt := now.Add(24 * time.Hour)
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "react",
|
||||
Version: "18.2.0",
|
||||
StorageKey: "npm/react/18.2.0",
|
||||
CachedAt: now,
|
||||
LastAccessed: now,
|
||||
ExpiresAt: &expiresAt,
|
||||
}
|
||||
m.On("GetPackage", mock.Anything, "npm", "react", "18.2.0").Return(pkg, nil)
|
||||
s.On("Get", mock.Anything, "npm/react/18.2.0").Return(io.NopCloser(strings.NewReader("cached data")), nil)
|
||||
m.On("UpdateDownloadCount", mock.Anything, "npm", "react", "18.2.0").Return(nil)
|
||||
},
|
||||
wantFromCache: true,
|
||||
wantErr: false,
|
||||
},
|
||||
// GOOD: Cache miss - fetch from upstream
|
||||
{
|
||||
name: "cache miss - fetch from upstream",
|
||||
registry: "npm",
|
||||
packageName: "lodash",
|
||||
version: "4.17.21",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("GetPackage", mock.Anything, "npm", "lodash", "4.17.21").Return(nil, errors.New("not found"))
|
||||
s.On("GetQuota", mock.Anything).Return(&storage.QuotaInfo{Used: 100, Available: 900, Limit: 1000}, nil)
|
||||
s.On("Put", mock.Anything, "npm/lodash/4.17.21", mock.Anything, mock.Anything).Return(nil)
|
||||
m.On("SavePackage", mock.Anything, mock.Anything).Return(nil)
|
||||
s.On("Get", mock.Anything, "npm/lodash/4.17.21").Return(io.NopCloser(strings.NewReader("upstream data")), nil)
|
||||
},
|
||||
fetchFunc: func(ctx context.Context) (io.ReadCloser, string, error) {
|
||||
return io.NopCloser(strings.NewReader("upstream data")), "https://registry.npmjs.org/lodash", nil
|
||||
},
|
||||
wantFromCache: false,
|
||||
wantErr: false,
|
||||
},
|
||||
// WRONG: Expired package
|
||||
{
|
||||
name: "expired package - re-fetch",
|
||||
registry: "npm",
|
||||
packageName: "expired-pkg",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
now := time.Now()
|
||||
expiresAt := now.Add(-1 * time.Hour) // Expired 1 hour ago
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "expired-pkg",
|
||||
Version: "1.0.0",
|
||||
StorageKey: "npm/expired-pkg/1.0.0",
|
||||
ExpiresAt: &expiresAt,
|
||||
}
|
||||
m.On("GetPackage", mock.Anything, "npm", "expired-pkg", "1.0.0").Return(pkg, nil)
|
||||
m.On("DeletePackage", mock.Anything, "npm", "expired-pkg", "1.0.0").Return(nil)
|
||||
s.On("Delete", mock.Anything, "npm/expired-pkg/1.0.0").Return(nil)
|
||||
s.On("GetQuota", mock.Anything).Return(&storage.QuotaInfo{Used: 100, Available: 900, Limit: 1000}, nil)
|
||||
s.On("Put", mock.Anything, "npm/expired-pkg/1.0.0", mock.Anything, mock.Anything).Return(nil)
|
||||
m.On("SavePackage", mock.Anything, mock.Anything).Return(nil)
|
||||
s.On("Get", mock.Anything, "npm/expired-pkg/1.0.0").Return(io.NopCloser(strings.NewReader("refreshed data")), nil)
|
||||
},
|
||||
fetchFunc: func(ctx context.Context) (io.ReadCloser, string, error) {
|
||||
return io.NopCloser(strings.NewReader("refreshed data")), "https://registry.npmjs.org/expired-pkg", nil
|
||||
},
|
||||
wantFromCache: false,
|
||||
wantErr: false,
|
||||
},
|
||||
// BAD: Fetch function is nil and package not cached
|
||||
{
|
||||
name: "nil fetch function and not cached",
|
||||
registry: "npm",
|
||||
packageName: "missing",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("GetPackage", mock.Anything, "npm", "missing", "1.0.0").Return(nil, errors.New("not found"))
|
||||
},
|
||||
fetchFunc: nil,
|
||||
wantErr: true,
|
||||
errContains: "package not found and no fetch function provided",
|
||||
},
|
||||
// BAD: Upstream fetch fails
|
||||
{
|
||||
name: "upstream fetch error",
|
||||
registry: "npm",
|
||||
packageName: "fail-pkg",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("GetPackage", mock.Anything, "npm", "fail-pkg", "1.0.0").Return(nil, errors.New("not found"))
|
||||
},
|
||||
fetchFunc: func(ctx context.Context) (io.ReadCloser, string, error) {
|
||||
return nil, "", errors.New("upstream error")
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "failed to fetch from upstream",
|
||||
},
|
||||
// EDGE: Metadata exists but storage missing
|
||||
{
|
||||
name: "metadata exists but storage missing - inconsistency",
|
||||
registry: "npm",
|
||||
packageName: "inconsistent",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
now := time.Now()
|
||||
expiresAt := now.Add(24 * time.Hour)
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "inconsistent",
|
||||
Version: "1.0.0",
|
||||
StorageKey: "npm/inconsistent/1.0.0",
|
||||
ExpiresAt: &expiresAt,
|
||||
}
|
||||
m.On("GetPackage", mock.Anything, "npm", "inconsistent", "1.0.0").Return(pkg, nil)
|
||||
// First Get fails (storage missing)
|
||||
s.On("Get", mock.Anything, "npm/inconsistent/1.0.0").Return(nil, errors.New("not found")).Once()
|
||||
m.On("DeletePackage", mock.Anything, "npm", "inconsistent", "1.0.0").Return(nil)
|
||||
s.On("GetQuota", mock.Anything).Return(&storage.QuotaInfo{Used: 100, Available: 900, Limit: 1000}, nil)
|
||||
s.On("Put", mock.Anything, "npm/inconsistent/1.0.0", mock.Anything, mock.Anything).Return(nil)
|
||||
m.On("SavePackage", mock.Anything, mock.Anything).Return(nil)
|
||||
// Second Get succeeds (after re-storing)
|
||||
s.On("Get", mock.Anything, "npm/inconsistent/1.0.0").Return(io.NopCloser(strings.NewReader("recovered data")), nil).Once()
|
||||
},
|
||||
fetchFunc: func(ctx context.Context) (io.ReadCloser, string, error) {
|
||||
return io.NopCloser(strings.NewReader("recovered data")), "https://registry.npmjs.org/inconsistent", nil
|
||||
},
|
||||
wantFromCache: false,
|
||||
wantErr: false,
|
||||
},
|
||||
// EDGE: Storage save fails
|
||||
{
|
||||
name: "storage save fails",
|
||||
registry: "npm",
|
||||
packageName: "save-fail",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("GetPackage", mock.Anything, "npm", "save-fail", "1.0.0").Return(nil, errors.New("not found"))
|
||||
s.On("GetQuota", mock.Anything).Return(&storage.QuotaInfo{Used: 100, Available: 900, Limit: 1000}, nil)
|
||||
s.On("Put", mock.Anything, "npm/save-fail/1.0.0", mock.Anything, mock.Anything).Return(errors.New("storage error"))
|
||||
},
|
||||
fetchFunc: func(ctx context.Context) (io.ReadCloser, string, error) {
|
||||
return io.NopCloser(strings.NewReader("data")), "https://registry.npmjs.org/save-fail", nil
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "storage error",
|
||||
},
|
||||
// EDGE: Metadata save fails (should cleanup storage)
|
||||
{
|
||||
name: "metadata save fails - storage cleanup",
|
||||
registry: "npm",
|
||||
packageName: "meta-fail",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("GetPackage", mock.Anything, "npm", "meta-fail", "1.0.0").Return(nil, errors.New("not found"))
|
||||
s.On("GetQuota", mock.Anything).Return(&storage.QuotaInfo{Used: 100, Available: 900, Limit: 1000}, nil)
|
||||
s.On("Put", mock.Anything, "npm/meta-fail/1.0.0", mock.Anything, mock.Anything).Return(nil)
|
||||
m.On("SavePackage", mock.Anything, mock.Anything).Return(errors.New("metadata error"))
|
||||
s.On("Delete", mock.Anything, "npm/meta-fail/1.0.0").Return(nil)
|
||||
},
|
||||
fetchFunc: func(ctx context.Context) (io.ReadCloser, string, error) {
|
||||
return io.NopCloser(strings.NewReader("data")), "https://registry.npmjs.org/meta-fail", nil
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "metadata error",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
if tt.setupMock != nil {
|
||||
tt.setupMock(mockStorage, mockMetadata)
|
||||
}
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{
|
||||
DefaultTTL: 24 * time.Hour,
|
||||
CleanupInterval: 1 * time.Hour,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
ctx := context.Background()
|
||||
entry, err := manager.Get(ctx, tt.registry, tt.packageName, tt.version, tt.fetchFunc)
|
||||
|
||||
if tt.wantErr {
|
||||
require.Error(t, err)
|
||||
if tt.errContains != "" {
|
||||
assert.Contains(t, err.Error(), tt.errContains)
|
||||
}
|
||||
assert.Nil(t, entry)
|
||||
} else {
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, entry)
|
||||
assert.Equal(t, tt.wantFromCache, entry.FromCache)
|
||||
assert.NotNil(t, entry.Data)
|
||||
// Read and verify data exists
|
||||
data, _ := io.ReadAll(entry.Data)
|
||||
assert.NotEmpty(t, data)
|
||||
}
|
||||
|
||||
mockStorage.AssertExpectations(t)
|
||||
mockMetadata.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestDelete tests package deletion
|
||||
func TestDelete(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
registry string
|
||||
packageName string
|
||||
version string
|
||||
setupMock func(*MockStorageBackend, *MockMetadataStore)
|
||||
wantErr bool
|
||||
errContains string
|
||||
}{
|
||||
// GOOD: Successful deletion
|
||||
{
|
||||
name: "successful deletion",
|
||||
registry: "npm",
|
||||
packageName: "react",
|
||||
version: "18.2.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "react",
|
||||
Version: "18.2.0",
|
||||
StorageKey: "npm/react/18.2.0",
|
||||
}
|
||||
m.On("GetPackage", mock.Anything, "npm", "react", "18.2.0").Return(pkg, nil)
|
||||
s.On("Delete", mock.Anything, "npm/react/18.2.0").Return(nil)
|
||||
m.On("DeletePackage", mock.Anything, "npm", "react", "18.2.0").Return(nil)
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
// WRONG: Package not found
|
||||
{
|
||||
name: "package not found",
|
||||
registry: "npm",
|
||||
packageName: "missing",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("GetPackage", mock.Anything, "npm", "missing", "1.0.0").Return(nil, errors.New("not found"))
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "not found",
|
||||
},
|
||||
// EDGE: Storage delete fails but metadata succeeds
|
||||
{
|
||||
name: "storage delete fails",
|
||||
registry: "npm",
|
||||
packageName: "storage-fail",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "storage-fail",
|
||||
Version: "1.0.0",
|
||||
StorageKey: "npm/storage-fail/1.0.0",
|
||||
}
|
||||
m.On("GetPackage", mock.Anything, "npm", "storage-fail", "1.0.0").Return(pkg, nil)
|
||||
s.On("Delete", mock.Anything, "npm/storage-fail/1.0.0").Return(errors.New("storage error"))
|
||||
m.On("DeletePackage", mock.Anything, "npm", "storage-fail", "1.0.0").Return(nil)
|
||||
},
|
||||
wantErr: false, // Metadata delete still succeeds
|
||||
},
|
||||
// EDGE: Metadata delete fails
|
||||
{
|
||||
name: "metadata delete fails",
|
||||
registry: "npm",
|
||||
packageName: "meta-fail",
|
||||
version: "1.0.0",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "meta-fail",
|
||||
Version: "1.0.0",
|
||||
StorageKey: "npm/meta-fail/1.0.0",
|
||||
}
|
||||
m.On("GetPackage", mock.Anything, "npm", "meta-fail", "1.0.0").Return(pkg, nil)
|
||||
s.On("Delete", mock.Anything, "npm/meta-fail/1.0.0").Return(nil)
|
||||
m.On("DeletePackage", mock.Anything, "npm", "meta-fail", "1.0.0").Return(errors.New("metadata error"))
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "metadata error",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
if tt.setupMock != nil {
|
||||
tt.setupMock(mockStorage, mockMetadata)
|
||||
}
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
ctx := context.Background()
|
||||
err = manager.Delete(ctx, tt.registry, tt.packageName, tt.version)
|
||||
|
||||
if tt.wantErr {
|
||||
require.Error(t, err)
|
||||
if tt.errContains != "" {
|
||||
assert.Contains(t, err.Error(), tt.errContains)
|
||||
}
|
||||
} else {
|
||||
require.NoError(t, err)
|
||||
}
|
||||
|
||||
mockStorage.AssertExpectations(t)
|
||||
mockMetadata.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestHealth tests health check functionality
|
||||
func TestHealth(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func(*MockStorageBackend, *MockMetadataStore)
|
||||
wantErr bool
|
||||
errContains string
|
||||
}{
|
||||
// GOOD: Both healthy
|
||||
{
|
||||
name: "both storage and metadata healthy",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Health", mock.Anything).Return(nil)
|
||||
m.On("Health", mock.Anything).Return(nil)
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
// WRONG: Storage unhealthy
|
||||
{
|
||||
name: "storage unhealthy",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Health", mock.Anything).Return(errors.New("storage error"))
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "storage health check failed",
|
||||
},
|
||||
// WRONG: Metadata unhealthy
|
||||
{
|
||||
name: "metadata unhealthy",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Health", mock.Anything).Return(nil)
|
||||
m.On("Health", mock.Anything).Return(errors.New("metadata error"))
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "metadata health check failed",
|
||||
},
|
||||
// BAD: Both unhealthy
|
||||
{
|
||||
name: "both unhealthy",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Health", mock.Anything).Return(errors.New("storage error"))
|
||||
},
|
||||
wantErr: true,
|
||||
errContains: "storage health check failed",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
if tt.setupMock != nil {
|
||||
tt.setupMock(mockStorage, mockMetadata)
|
||||
}
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
ctx := context.Background()
|
||||
err = manager.Health(ctx)
|
||||
|
||||
if tt.wantErr {
|
||||
require.Error(t, err)
|
||||
if tt.errContains != "" {
|
||||
assert.Contains(t, err.Error(), tt.errContains)
|
||||
}
|
||||
} else {
|
||||
require.NoError(t, err)
|
||||
}
|
||||
|
||||
mockStorage.AssertExpectations(t)
|
||||
mockMetadata.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetStats tests statistics retrieval
|
||||
func TestGetStats(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
expectedStats := &metadata.Stats{
|
||||
Registry: "npm",
|
||||
TotalPackages: 100,
|
||||
TotalSize: 1024 * 1024 * 100,
|
||||
TotalDownloads: 5000,
|
||||
}
|
||||
|
||||
mockMetadata.On("GetStats", mock.Anything, "npm").Return(expectedStats, nil)
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
ctx := context.Background()
|
||||
stats, err := manager.GetStats(ctx, "npm")
|
||||
|
||||
require.NoError(t, err)
|
||||
assert.Equal(t, expectedStats, stats)
|
||||
mockMetadata.AssertExpectations(t)
|
||||
}
|
||||
|
||||
// TestClose tests manager cleanup
|
||||
func TestClose(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
setupMock func(*MockStorageBackend, *MockMetadataStore)
|
||||
wantErr bool
|
||||
}{
|
||||
// GOOD: Clean close
|
||||
{
|
||||
name: "both close successfully",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Close").Return(nil)
|
||||
m.On("Close").Return(nil)
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
// WRONG: Storage close fails
|
||||
{
|
||||
name: "storage close fails",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Close").Return(errors.New("storage error"))
|
||||
m.On("Close").Return(nil)
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
// WRONG: Metadata close fails
|
||||
{
|
||||
name: "metadata close fails",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Close").Return(nil)
|
||||
m.On("Close").Return(errors.New("metadata error"))
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
// BAD: Both close fail
|
||||
{
|
||||
name: "both close fail",
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
s.On("Close").Return(errors.New("storage error"))
|
||||
m.On("Close").Return(errors.New("metadata error"))
|
||||
},
|
||||
wantErr: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
if tt.setupMock != nil {
|
||||
tt.setupMock(mockStorage, mockMetadata)
|
||||
}
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
err = manager.Close() // #nosec G104 -- Cleanup, error not critical
|
||||
|
||||
if tt.wantErr {
|
||||
require.Error(t, err)
|
||||
} else {
|
||||
require.NoError(t, err)
|
||||
}
|
||||
|
||||
mockStorage.AssertExpectations(t)
|
||||
mockMetadata.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestEvict tests LRU eviction
|
||||
func TestEvict(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
needed int64
|
||||
setupMock func(*MockStorageBackend, *MockMetadataStore)
|
||||
wantErr bool
|
||||
errContains string
|
||||
}{
|
||||
// GOOD: Successful eviction
|
||||
{
|
||||
name: "evict enough to free space",
|
||||
needed: 200,
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
packages := []*metadata.Package{
|
||||
{
|
||||
ID: "1",
|
||||
Name: "old-pkg-1",
|
||||
Version: "1.0.0",
|
||||
Registry: "npm",
|
||||
StorageKey: "npm/old-pkg-1/1.0.0",
|
||||
Size: 100,
|
||||
},
|
||||
{
|
||||
ID: "2",
|
||||
Name: "old-pkg-2",
|
||||
Version: "1.0.0",
|
||||
Registry: "npm",
|
||||
StorageKey: "npm/old-pkg-2/1.0.0",
|
||||
Size: 150,
|
||||
},
|
||||
}
|
||||
m.On("ListPackages", mock.Anything, mock.MatchedBy(func(opts *metadata.ListOptions) bool {
|
||||
return opts.SortBy == "last_accessed" && !opts.SortDesc
|
||||
})).Return(packages, nil).Once()
|
||||
|
||||
s.On("Delete", mock.Anything, "npm/old-pkg-1/1.0.0").Return(nil)
|
||||
m.On("DeletePackage", mock.Anything, "npm", "old-pkg-1", "1.0.0").Return(nil)
|
||||
s.On("Delete", mock.Anything, "npm/old-pkg-2/1.0.0").Return(nil)
|
||||
m.On("DeletePackage", mock.Anything, "npm", "old-pkg-2", "1.0.0").Return(nil)
|
||||
},
|
||||
wantErr: false,
|
||||
},
|
||||
// EDGE: No packages to evict
|
||||
{
|
||||
name: "no packages available to evict",
|
||||
needed: 100,
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("ListPackages", mock.Anything, mock.Anything).Return([]*metadata.Package{}, nil)
|
||||
},
|
||||
wantErr: false, // Doesn't error, just can't free enough
|
||||
},
|
||||
// EDGE: Eviction list error
|
||||
{
|
||||
name: "list packages fails",
|
||||
needed: 100,
|
||||
setupMock: func(s *MockStorageBackend, m *MockMetadataStore) {
|
||||
m.On("ListPackages", mock.Anything, mock.Anything).Return(nil, errors.New("list error"))
|
||||
},
|
||||
wantErr: false, // Doesn't error, just can't complete
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
if tt.setupMock != nil {
|
||||
tt.setupMock(mockStorage, mockMetadata)
|
||||
}
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
ctx := context.Background()
|
||||
err = manager.evict(ctx, tt.needed)
|
||||
|
||||
if tt.wantErr {
|
||||
require.Error(t, err)
|
||||
if tt.errContains != "" {
|
||||
assert.Contains(t, err.Error(), tt.errContains)
|
||||
}
|
||||
} else {
|
||||
require.NoError(t, err)
|
||||
}
|
||||
|
||||
mockStorage.AssertExpectations(t)
|
||||
mockMetadata.AssertExpectations(t)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenerateStorageKey tests storage key generation
|
||||
func TestGenerateStorageKey(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
tests := []struct {
|
||||
registry string
|
||||
name string
|
||||
version string
|
||||
expected string
|
||||
}{
|
||||
{"npm", "react", "18.2.0", "npm/react/18.2.0"},
|
||||
{"pypi", "requests", "2.28.0", "pypi/requests/2.28.0"},
|
||||
{"go", "github.com/gin-gonic/gin", "v1.9.0", "go/github.com/gin-gonic/gin/v1.9.0"},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.expected, func(t *testing.T) {
|
||||
key := manager.generateStorageKey(tt.registry, tt.name, tt.version)
|
||||
assert.Equal(t, tt.expected, key)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestConcurrentGet tests concurrent access doesn't cause data races
|
||||
func TestConcurrentGet(t *testing.T) {
|
||||
mockStorage := &MockStorageBackend{}
|
||||
mockMetadata := &MockMetadataStore{}
|
||||
|
||||
// Setup mocks for concurrent access
|
||||
now := time.Now()
|
||||
expiresAt := now.Add(24 * time.Hour)
|
||||
pkg := &metadata.Package{
|
||||
ID: "test-id",
|
||||
Registry: "npm",
|
||||
Name: "concurrent",
|
||||
Version: "1.0.0",
|
||||
StorageKey: "npm/concurrent/1.0.0",
|
||||
CachedAt: now,
|
||||
LastAccessed: now,
|
||||
ExpiresAt: &expiresAt,
|
||||
}
|
||||
|
||||
// Use Maybe() to allow variable number of calls due to singleflight deduplication
|
||||
mockMetadata.On("GetPackage", mock.Anything, "npm", "concurrent", "1.0.0").Return(pkg, nil).Maybe()
|
||||
mockStorage.On("Get", mock.Anything, "npm/concurrent/1.0.0").Return(
|
||||
io.NopCloser(bytes.NewReader([]byte("test data"))), nil).Maybe()
|
||||
mockMetadata.On("UpdateDownloadCount", mock.Anything, "npm", "concurrent", "1.0.0").Return(nil).Maybe()
|
||||
|
||||
manager, err := New(mockStorage, mockMetadata, nil, Config{})
|
||||
require.NoError(t, err)
|
||||
|
||||
ctx := context.Background()
|
||||
const numGoroutines = 10
|
||||
|
||||
// Run concurrent gets
|
||||
errs := make(chan error, numGoroutines)
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func() {
|
||||
_, err := manager.Get(ctx, "npm", "concurrent", "1.0.0", nil)
|
||||
errs <- err
|
||||
}()
|
||||
}
|
||||
|
||||
// Collect results
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
err := <-errs
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
// Verify at least one call was made (singleflight may deduplicate others)
|
||||
mockMetadata.AssertCalled(t, "GetPackage", mock.Anything, "npm", "concurrent", "1.0.0")
|
||||
}
|
||||
Reference in New Issue
Block a user