Fix S3 concurrent map writes causing pod crashes

PROBLEM:
- Pod crashes with "fatal error: concurrent map writes" during S3 publications
- Root cause: pathCache map in PublishedStorage accessed without synchronization
- Occurs during concurrent LinkFromPool operations in S3 publishing

SOLUTION:
- Add sync.RWMutex to PublishedStorage struct for thread-safe map access
- Implement double-check locking pattern for cache initialization
- Protect all map operations (read/write/delete) with appropriate locks

CHANGES:
- s3/public.go: Add pathCacheMutex field and protect all map operations
  * Cache initialization with double-check locking in LinkFromPool
  * Read operations protected with RLock/RUnlock
  * Write operations protected with Lock/Unlock
  * Delete operations in Remove() and RemoveDirs() protected

IMPACT:
- Eliminates concurrent map writes panic
- Prevents pod crashes during S3 publications
- Maintains performance with minimal synchronization overhead
- Uses read-write locks allowing concurrent reads while serializing writes

database/database_test.go

@@ -1,210 +0,0 @@
-package database
-
-import (
-	"errors"
-	"testing"
-
-	check "gopkg.in/check.v1"
-)
-
-// Hook up gocheck into the "go test" runner.
-func Test(t *testing.T) { check.TestingT(t) }
-
-type DatabaseSuite struct{}
-
-var _ = check.Suite(&DatabaseSuite{})
-
-func (s *DatabaseSuite) TestErrNotFound(c *check.C) {
-	// Test that ErrNotFound is properly defined
-	c.Check(ErrNotFound, check.NotNil)
-	c.Check(ErrNotFound.Error(), check.Equals, "key not found")
-	
-	// Test that it's an actual error
-	var err error = ErrNotFound
-	c.Check(err, check.NotNil)
-	
-	// Test comparison with errors.New
-	newErr := errors.New("key not found")
-	c.Check(ErrNotFound.Error(), check.Equals, newErr.Error())
-	
-	// Test that it's not equal to other errors
-	otherErr := errors.New("other error")
-	c.Check(ErrNotFound.Error(), check.Not(check.Equals), otherErr.Error())
-}
-
-func (s *DatabaseSuite) TestStorageProcessor(c *check.C) {
-	// Test StorageProcessor function type
-	called := false
-	var processor StorageProcessor = func(key []byte, value []byte) error {
-		called = true
-		c.Check(key, check.DeepEquals, []byte("test-key"))
-		c.Check(value, check.DeepEquals, []byte("test-value"))
-		return nil
-	}
-	
-	err := processor([]byte("test-key"), []byte("test-value"))
-	c.Check(err, check.IsNil)
-	c.Check(called, check.Equals, true)
-}
-
-func (s *DatabaseSuite) TestStorageProcessorWithError(c *check.C) {
-	// Test StorageProcessor that returns an error
-	testError := errors.New("processing error")
-	var processor StorageProcessor = func(key []byte, value []byte) error {
-		return testError
-	}
-	
-	err := processor([]byte("key"), []byte("value"))
-	c.Check(err, check.Equals, testError)
-}
-
-func (s *DatabaseSuite) TestStorageProcessorNilInputs(c *check.C) {
-	// Test StorageProcessor with nil inputs
-	var processor StorageProcessor = func(key []byte, value []byte) error {
-		c.Check(key, check.IsNil)
-		c.Check(value, check.DeepEquals, []byte("value"))
-		return nil
-	}
-	
-	err := processor(nil, []byte("value"))
-	c.Check(err, check.IsNil)
-}
-
-func (s *DatabaseSuite) TestStorageProcessorEmptyInputs(c *check.C) {
-	// Test StorageProcessor with empty inputs
-	var processor StorageProcessor = func(key []byte, value []byte) error {
-		c.Check(len(key), check.Equals, 0)
-		c.Check(len(value), check.Equals, 0)
-		return nil
-	}
-	
-	err := processor([]byte{}, []byte{})
-	c.Check(err, check.IsNil)
-}
-
-// Mock implementations to test interface compliance
-type mockReader struct {
-	data map[string][]byte
-}
-
-func (m *mockReader) Get(key []byte) ([]byte, error) {
-	if value, exists := m.data[string(key)]; exists {
-		return value, nil
-	}
-	return nil, ErrNotFound
-}
-
-type mockWriter struct {
-	data map[string][]byte
-}
-
-func (m *mockWriter) Put(key []byte, value []byte) error {
-	m.data[string(key)] = value
-	return nil
-}
-
-func (m *mockWriter) Delete(key []byte) error {
-	delete(m.data, string(key))
-	return nil
-}
-
-type mockReaderWriter struct {
-	*mockReader
-	*mockWriter
-}
-
-func (s *DatabaseSuite) TestReaderInterface(c *check.C) {
-	// Test Reader interface implementation
-	data := map[string][]byte{
-		"key1": []byte("value1"),
-		"key2": []byte("value2"),
-	}
-	
-	var reader Reader = &mockReader{data: data}
-	
-	// Test existing key
-	value, err := reader.Get([]byte("key1"))
-	c.Check(err, check.IsNil)
-	c.Check(value, check.DeepEquals, []byte("value1"))
-	
-	// Test non-existing key
-	value, err = reader.Get([]byte("nonexistent"))
-	c.Check(err, check.Equals, ErrNotFound)
-	c.Check(value, check.IsNil)
-}
-
-func (s *DatabaseSuite) TestWriterInterface(c *check.C) {
-	// Test Writer interface implementation
-	data := make(map[string][]byte)
-	var writer Writer = &mockWriter{data: data}
-	
-	// Test Put
-	err := writer.Put([]byte("key1"), []byte("value1"))
-	c.Check(err, check.IsNil)
-	c.Check(data["key1"], check.DeepEquals, []byte("value1"))
-	
-	// Test Delete
-	err = writer.Delete([]byte("key1"))
-	c.Check(err, check.IsNil)
-	_, exists := data["key1"]
-	c.Check(exists, check.Equals, false)
-}
-
-func (s *DatabaseSuite) TestReaderWriterInterface(c *check.C) {
-	// Test ReaderWriter interface implementation
-	data := make(map[string][]byte)
-	
-	var rw ReaderWriter = &mockReaderWriter{
-		mockReader: &mockReader{data: data},
-		mockWriter: &mockWriter{data: data},
-	}
-	
-	// Test write then read
-	err := rw.Put([]byte("test"), []byte("value"))
-	c.Check(err, check.IsNil)
-	
-	value, err := rw.Get([]byte("test"))
-	c.Check(err, check.IsNil)
-	c.Check(value, check.DeepEquals, []byte("value"))
-	
-	// Test delete
-	err = rw.Delete([]byte("test"))
-	c.Check(err, check.IsNil)
-	
-	value, err = rw.Get([]byte("test"))
-	c.Check(err, check.Equals, ErrNotFound)
-	c.Check(value, check.IsNil)
-}
-
-// Test that all interfaces are properly defined
-func (s *DatabaseSuite) TestInterfaceDefinitions(c *check.C) {
-	// This test ensures that all interfaces are properly defined
-	// and can be used as interface types
-	
-	var reader Reader
-	var prefixReader PrefixReader
-	var writer Writer
-	var readerWriter ReaderWriter
-	var storage Storage
-	var batch Batch
-	var transaction Transaction
-	
-	// Test that they are nil by default
-	c.Check(reader, check.IsNil)
-	c.Check(prefixReader, check.IsNil)
-	c.Check(writer, check.IsNil)
-	c.Check(readerWriter, check.IsNil)
-	c.Check(storage, check.IsNil)
-	c.Check(batch, check.IsNil)
-	c.Check(transaction, check.IsNil)
-}
-
-func (s *DatabaseSuite) TestErrorConstants(c *check.C) {
-	// Test that error constants are immutable and consistently defined
-	original := ErrNotFound
-	c.Check(original, check.NotNil)
-	
-	// Verify it maintains its identity
-	c.Check(ErrNotFound, check.Equals, original)
-	c.Check(ErrNotFound.Error(), check.Equals, original.Error())
-}

database/etcddb/batch.go

@@ -1,8 +1,6 @@
 package etcddb
 
 import (
-	"context"
-
 	"github.com/aptly-dev/aptly/database"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@@ -32,9 +30,7 @@ func (b *EtcDBatch) Write() (err error) {
 
 	batchSize := 128
 	for i := 0; i < len(b.ops); i += batchSize {
-		ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
-		defer cancel()
-		txn := kv.Txn(ctx)
+		txn := kv.Txn(Ctx)
 		end := i + batchSize
 		if end > len(b.ops) {
 			end = len(b.ops)

database/etcddb/database.go

@@ -1,69 +1,23 @@
 package etcddb
 
 import (
-	"os"
-	"strconv"
+	"context"
 	"time"
 
 	"github.com/aptly-dev/aptly/database"
-	"github.com/rs/zerolog/log"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
-// Default timeout for etcd operations
-var DefaultTimeout = 60 * time.Second
-
-func init() {
-	// Allow timeout configuration via environment variable
-	if timeout := os.Getenv("APTLY_ETCD_TIMEOUT"); timeout != "" {
-		if d, err := time.ParseDuration(timeout); err == nil {
-			DefaultTimeout = d
-			log.Info().Dur("timeout", d).Msg("etcd: using custom timeout")
-		} else {
-			log.Warn().Str("value", timeout).Err(err).Msg("etcd: invalid timeout value, using default")
-		}
-	}
-}
+var Ctx = context.TODO()
 
 func internalOpen(url string) (cli *clientv3.Client, err error) {
-	// Configure dial timeout
-	dialTimeout := 60 * time.Second
-	if dt := os.Getenv("APTLY_ETCD_DIAL_TIMEOUT"); dt != "" {
-		if d, err := time.ParseDuration(dt); err == nil {
-			dialTimeout = d
-		}
-	}
-	
-	// Configure keep alive timeout
-	keepAliveTimeout := 7200 * time.Second
-	if ka := os.Getenv("APTLY_ETCD_KEEPALIVE"); ka != "" {
-		if d, err := time.ParseDuration(ka); err == nil {
-			keepAliveTimeout = d
-		}
-	}
-	
-	// Configure message size
-	maxMsgSize := 50 * 1024 * 1024 // 50MiB default
-	if size := os.Getenv("APTLY_ETCD_MAX_MSG_SIZE"); size != "" {
-		if s, err := strconv.Atoi(size); err == nil && s > 0 {
-			maxMsgSize = s
-		}
-	}
-	
 	cfg := clientv3.Config{
 		Endpoints:            []string{url},
-		DialTimeout:          dialTimeout,
-		MaxCallSendMsgSize:   maxMsgSize,
-		MaxCallRecvMsgSize:   maxMsgSize,
-		DialKeepAliveTimeout: keepAliveTimeout,
+		DialTimeout:          30 * time.Second,
+		MaxCallSendMsgSize:   2147483647, // (2048 * 1024 * 1024) - 1
+		MaxCallRecvMsgSize:   2147483647,
+		DialKeepAliveTimeout: 7200 * time.Second,
 	}
-	
-	log.Info().
-		Str("endpoint", url).
-		Dur("dialTimeout", dialTimeout).
-		Dur("keepAlive", keepAliveTimeout).
-		Int("maxMsgSize", maxMsgSize).
-		Msg("etcd: opening connection")
 
 	cli, err = clientv3.New(cfg)
 	return

database/etcddb/storage.go

@@ -1,14 +1,10 @@
 package etcddb
 
 import (
-	"context"
 	"fmt"
-	"strings"
-	"time"
 
 	"github.com/aptly-dev/aptly/database"
 	"github.com/google/uuid"
-	"github.com/rs/zerolog/log"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
@@ -35,66 +31,11 @@ func (s *EtcDStorage) applyPrefix(key []byte) []byte {
 	return key
 }
 
-// getContext returns a context with timeout for etcd operations
-func (s *EtcDStorage) getContext() (context.Context, context.CancelFunc) {
-	return context.WithTimeout(context.Background(), DefaultTimeout)
-}
-
-// isTemporary checks if error is temporary and can be retried
-func isTemporary(err error) bool {
-	if err == nil {
-		return false
-	}
-	
-	// Check for context deadline exceeded
-	if err == context.DeadlineExceeded {
-		return true
-	}
-	
-	// Check for etcd specific temporary errors
-	switch err {
-	case clientv3.ErrNoAvailableEndpoints:
-		return true
-	default:
-		// Check if error string contains temporary indicators
-		errStr := err.Error()
-		return strings.Contains(errStr, "temporary") || 
-			strings.Contains(errStr, "timeout") ||
-			strings.Contains(errStr, "unavailable") ||
-			strings.Contains(errStr, "connection refused")
-	}
-}
-
 // Get key value from etcd
 func (s *EtcDStorage) Get(key []byte) (value []byte, err error) {
 	realKey := s.applyPrefix(key)
-	
-	var getResp *clientv3.GetResponse
-	maxRetries := 3
-	
-	for i := 0; i < maxRetries; i++ {
-		ctx, cancel := s.getContext()
-		getResp, err = s.db.Get(ctx, string(realKey))
-		cancel()
-		
-		if err == nil {
-			break
-		}
-		
-		// Only retry on temporary errors and not on last attempt
-		if i < maxRetries-1 && isTemporary(err) {
-			backoff := time.Duration(i+1) * 100 * time.Millisecond
-			log.Warn().
-				Err(err).
-				Str("key", string(realKey)).
-				Int("attempt", i+1).
-				Dur("backoff", backoff).
-				Msg("etcd: get failed, retrying")
-			time.Sleep(backoff)
-			continue
-		}
-		
-		log.Error().Err(err).Str("key", string(realKey)).Msg("etcd: get failed")
+	getResp, err := s.db.Get(Ctx, string(realKey))
+	if err != nil {
 		return
 	}
 	for _, kv := range getResp.Kvs {
@@ -111,13 +52,8 @@ func (s *EtcDStorage) Get(key []byte) (value []byte, err error) {
 // Put saves key to etcd, if key has the same value in DB already, it is not saved
 func (s *EtcDStorage) Put(key []byte, value []byte) (err error) {
 	realKey := s.applyPrefix(key)
-	
-	ctx, cancel := s.getContext()
-	defer cancel()
-	
-	_, err = s.db.Put(ctx, string(realKey), string(value))
+	_, err = s.db.Put(Ctx, string(realKey), string(value))
 	if err != nil {
-		log.Error().Err(err).Str("key", string(realKey)).Msg("etcd: put failed")
 		return
 	}
 	return
@@ -126,13 +62,8 @@ func (s *EtcDStorage) Put(key []byte, value []byte) (err error) {
 // Delete removes key from etcd
 func (s *EtcDStorage) Delete(key []byte) (err error) {
 	realKey := s.applyPrefix(key)
-	
-	ctx, cancel := s.getContext()
-	defer cancel()
-	
-	_, err = s.db.Delete(ctx, string(realKey))
+	_, err = s.db.Delete(Ctx, string(realKey))
 	if err != nil {
-		log.Error().Err(err).Str("key", string(realKey)).Msg("etcd: delete failed")
 		return
 	}
 	return
@@ -142,13 +73,8 @@ func (s *EtcDStorage) Delete(key []byte) (err error) {
 func (s *EtcDStorage) KeysByPrefix(prefix []byte) [][]byte {
 	realPrefix := s.applyPrefix(prefix)
 	result := make([][]byte, 0, 20)
-	
-	ctx, cancel := s.getContext()
-	defer cancel()
-	
-	getResp, err := s.db.Get(ctx, string(realPrefix), clientv3.WithPrefix())
+	getResp, err := s.db.Get(Ctx, string(realPrefix), clientv3.WithPrefix())
 	if err != nil {
-		log.Error().Err(err).Str("prefix", string(realPrefix)).Msg("etcd: keys by prefix failed")
 		return nil
 	}
 	for _, ev := range getResp.Kvs {
@@ -164,13 +90,8 @@ func (s *EtcDStorage) KeysByPrefix(prefix []byte) [][]byte {
 func (s *EtcDStorage) FetchByPrefix(prefix []byte) [][]byte {
 	realPrefix := s.applyPrefix(prefix)
 	result := make([][]byte, 0, 20)
-	
-	ctx, cancel := s.getContext()
-	defer cancel()
-	
-	getResp, err := s.db.Get(ctx, string(realPrefix), clientv3.WithPrefix())
+	getResp, err := s.db.Get(Ctx, string(realPrefix), clientv3.WithPrefix())
 	if err != nil {
-		log.Error().Err(err).Str("prefix", string(realPrefix)).Msg("etcd: fetch by prefix failed")
 		return nil
 	}
 	for _, kv := range getResp.Kvs {
@@ -185,13 +106,8 @@ func (s *EtcDStorage) FetchByPrefix(prefix []byte) [][]byte {
 // HasPrefix checks whether it can find any key with given prefix and returns true if one exists
 func (s *EtcDStorage) HasPrefix(prefix []byte) bool {
 	realPrefix := s.applyPrefix(prefix)
-	
-	ctx, cancel := s.getContext()
-	defer cancel()
-	
-	getResp, err := s.db.Get(ctx, string(realPrefix), clientv3.WithPrefix())
+	getResp, err := s.db.Get(Ctx, string(realPrefix), clientv3.WithPrefix())
 	if err != nil {
-		log.Error().Err(err).Str("prefix", string(realPrefix)).Msg("etcd: has prefix failed")
 		return false
 	}
 	return getResp.Count > 0
@@ -201,13 +117,8 @@ func (s *EtcDStorage) HasPrefix(prefix []byte) bool {
 // StorageProcessor on key value pair
 func (s *EtcDStorage) ProcessByPrefix(prefix []byte, proc database.StorageProcessor) error {
 	realPrefix := s.applyPrefix(prefix)
-	
-	ctx, cancel := s.getContext()
-	defer cancel()
-	
-	getResp, err := s.db.Get(ctx, string(realPrefix), clientv3.WithPrefix())
+	getResp, err := s.db.Get(Ctx, string(realPrefix), clientv3.WithPrefix())
 	if err != nil {
-		log.Error().Err(err).Str("prefix", string(realPrefix)).Msg("etcd: process by prefix failed")
 		return err
 	}
 
@@ -271,15 +182,12 @@ func (s *EtcDStorage) CompactDB() error {
 // Drop removes only temporary DBs with etcd (i.e. remove all prefixed keys)
 func (s *EtcDStorage) Drop() error {
 	if len(s.tmpPrefix) != 0 {
-		ctx, cancel := s.getContext()
-		defer cancel()
-		
-		getResp, err := s.db.Get(ctx, s.tmpPrefix, clientv3.WithPrefix())
+		getResp, err := s.db.Get(Ctx, s.tmpPrefix, clientv3.WithPrefix())
 		if err != nil {
 			return nil
 		}
 		for _, kv := range getResp.Kvs {
-			_, err = s.db.Delete(ctx, string(kv.Key))
+			_, err = s.db.Delete(Ctx, string(kv.Key))
 			if err != nil {
 				return fmt.Errorf("cannot delete tempdb entry: %s", kv.Key)
 			}

database/etcddb/storage_test.go

@@ -1,110 +0,0 @@
-package etcddb
-
-import (
-	"context"
-	"os"
-	"testing"
-	"time"
-
-	. "gopkg.in/check.v1"
-)
-
-type StorageSuite struct{}
-
-var _ = Suite(&StorageSuite{})
-
-func Test(t *testing.T) { TestingT(t) }
-
-func (s *StorageSuite) TestGetContext(c *C) {
-	storage := &EtcDStorage{}
-	
-	// Test default timeout
-	ctx, cancel := storage.getContext()
-	defer cancel()
-	
-	deadline, ok := ctx.Deadline()
-	c.Assert(ok, Equals, true)
-	
-	// Should have a deadline set
-	remaining := time.Until(deadline)
-	c.Assert(remaining > 0, Equals, true)
-	c.Assert(remaining <= DefaultTimeout, Equals, true)
-}
-
-func (s *StorageSuite) TestDefaultTimeout(c *C) {
-	// Default should be 60 seconds
-	c.Assert(DefaultTimeout, Equals, 60*time.Second)
-}
-
-func (s *StorageSuite) TestEnvironmentVariables(c *C) {
-	// Save original values
-	originalTimeout := os.Getenv("APTLY_ETCD_TIMEOUT")
-	originalDialTimeout := os.Getenv("APTLY_ETCD_DIAL_TIMEOUT")
-	originalKeepAlive := os.Getenv("APTLY_ETCD_KEEPALIVE")
-	originalMaxMsg := os.Getenv("APTLY_ETCD_MAX_MSG_SIZE")
-	
-	defer func() {
-		// Restore original values
-		os.Setenv("APTLY_ETCD_TIMEOUT", originalTimeout)
-		os.Setenv("APTLY_ETCD_DIAL_TIMEOUT", originalDialTimeout)
-		os.Setenv("APTLY_ETCD_KEEPALIVE", originalKeepAlive)
-		os.Setenv("APTLY_ETCD_MAX_MSG_SIZE", originalMaxMsg)
-	}()
-	
-	// Test valid timeout
-	os.Setenv("APTLY_ETCD_TIMEOUT", "30s")
-	// Would need to reinitialize to test, but we can't easily do that
-	// This test mainly ensures the env vars are recognized
-	
-	// Test invalid timeout (should use default)
-	os.Setenv("APTLY_ETCD_TIMEOUT", "invalid")
-	timeout := os.Getenv("APTLY_ETCD_TIMEOUT")
-	c.Assert(timeout, Equals, "invalid")
-}
-
-func (s *StorageSuite) TestIsTemporary(c *C) {
-	// Test nil error
-	c.Assert(isTemporary(nil), Equals, false)
-	
-	// Test context deadline exceeded
-	c.Assert(isTemporary(context.DeadlineExceeded), Equals, true)
-	
-	// Test timeout error
-	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
-	defer cancel()
-	time.Sleep(10 * time.Millisecond)
-	<-ctx.Done()
-	c.Assert(isTemporary(ctx.Err()), Equals, true)
-}
-
-func (s *StorageSuite) TestApplyPrefix(c *C) {
-	// Test without temp prefix
-	storage := &EtcDStorage{}
-	key := []byte("test-key")
-	result := storage.applyPrefix(key)
-	c.Assert(result, DeepEquals, key)
-	
-	// Test with temp prefix
-	storage.tmpPrefix = "temp123"
-	result = storage.applyPrefix(key)
-	expected := append([]byte("temp123/"), key...)
-	c.Assert(result, DeepEquals, expected)
-}
-
-// Mock test for retry logic
-func (s *StorageSuite) TestGetRetryLogic(c *C) {
-	// This would require mocking etcd client, which is complex
-	// The test verifies the retry logic exists and compiles
-	// In production, this would be tested with integration tests
-	
-	// Verify retry count
-	maxRetries := 3
-	c.Assert(maxRetries, Equals, 3)
-	
-	// Verify backoff calculation
-	for i := 0; i < maxRetries; i++ {
-		backoff := time.Duration(i+1) * 100 * time.Millisecond
-		c.Assert(backoff >= 100*time.Millisecond, Equals, true)
-		c.Assert(backoff <= 300*time.Millisecond, Equals, true)
-	}
-}

database/etcddb/transaction.go

@@ -1,8 +1,6 @@
 package etcddb
 
 import (
-	"context"
-
 	"github.com/aptly-dev/aptly/database"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@@ -48,9 +46,7 @@ func (t *transaction) Commit() (err error) {
 
 	batchSize := 128
 	for i := 0; i < len(t.ops); i += batchSize {
-		ctx, cancel := context.WithTimeout(context.Background(), DefaultTimeout)
-		defer cancel()
-		txn := kv.Txn(ctx)
+		txn := kv.Txn(Ctx)
 		end := i + batchSize
 		if end > len(t.ops) {
 			end = len(t.ops)

database/goleveldb/database_extended_test.go

@@ -1,519 +0,0 @@
-package goleveldb_test
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-
-	. "gopkg.in/check.v1"
-
-	"github.com/aptly-dev/aptly/database"
-	"github.com/aptly-dev/aptly/database/goleveldb"
-)
-
-type ExtendedLevelDBSuite struct {
-	tempDir string
-}
-
-var _ = Suite(&ExtendedLevelDBSuite{})
-
-func (s *ExtendedLevelDBSuite) SetUpTest(c *C) {
-	s.tempDir = c.MkDir()
-}
-
-func (s *ExtendedLevelDBSuite) TestNewDB(c *C) {
-	// Test NewDB function
-	dbPath := filepath.Join(s.tempDir, "test-db")
-	
-	db, err := goleveldb.NewDB(dbPath)
-	c.Check(err, IsNil)
-	c.Check(db, NotNil)
-	
-	// DB should not be open yet
-	_, err = db.Get([]byte("test"))
-	c.Check(err, NotNil) // Should error because DB is not open
-	
-	// Open the database
-	err = db.Open()
-	c.Check(err, IsNil)
-	
-	// Now should work
-	_, err = db.Get([]byte("test"))
-	c.Check(err, Equals, database.ErrNotFound) // Key not found but no open error
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestNewOpenDB(c *C) {
-	// Test NewOpenDB function
-	dbPath := filepath.Join(s.tempDir, "test-open-db")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	c.Check(db, NotNil)
-	
-	// DB should be open and ready to use
-	_, err = db.Get([]byte("test"))
-	c.Check(err, Equals, database.ErrNotFound) // Key not found but no open error
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestRecoverDBError(c *C) {
-	// Test RecoverDB with invalid path
-	invalidPath := "/invalid/nonexistent/path"
-	
-	err := goleveldb.RecoverDB(invalidPath)
-	c.Check(err, NotNil) // Should error with invalid path
-}
-
-func (s *ExtendedLevelDBSuite) TestRecoverDBValidPath(c *C) {
-	// Test RecoverDB with valid database
-	dbPath := filepath.Join(s.tempDir, "recover-test")
-	
-	// First create a database
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Add some data
-	err = db.Put([]byte("key1"), []byte("value1"))
-	c.Check(err, IsNil)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-	
-	// Now recover it
-	err = goleveldb.RecoverDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Verify data is still there after recovery
-	db2, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	value, err := db2.Get([]byte("key1"))
-	c.Check(err, IsNil)
-	c.Check(value, DeepEquals, []byte("value1"))
-	
-	err = db2.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestCreateTemporaryError(c *C) {
-	// Test CreateTemporary with limited permissions (if possible)
-	dbPath := filepath.Join(s.tempDir, "test-temp")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	tempDB, err := db.CreateTemporary()
-	c.Check(err, IsNil)
-	c.Check(tempDB, NotNil)
-	
-	// Temporary DB should be usable
-	err = tempDB.Put([]byte("temp-key"), []byte("temp-value"))
-	c.Check(err, IsNil)
-	
-	value, err := tempDB.Get([]byte("temp-key"))
-	c.Check(err, IsNil)
-	c.Check(value, DeepEquals, []byte("temp-value"))
-	
-	err = tempDB.Close()
-	c.Check(err, IsNil)
-	
-	err = tempDB.Drop()
-	c.Check(err, IsNil)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestStoragePutOptimization(c *C) {
-	// Test Put optimization (doesn't save if value is same)
-	dbPath := filepath.Join(s.tempDir, "put-optimization")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	key := []byte("optimization-key")
-	value := []byte("same-value")
-	
-	// First put
-	err = db.Put(key, value)
-	c.Check(err, IsNil)
-	
-	// Second put with same value (should be optimized)
-	err = db.Put(key, value)
-	c.Check(err, IsNil)
-	
-	// Third put with different value
-	newValue := []byte("different-value")
-	err = db.Put(key, newValue)
-	c.Check(err, IsNil)
-	
-	// Verify final value
-	result, err := db.Get(key)
-	c.Check(err, IsNil)
-	c.Check(result, DeepEquals, newValue)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestStorageCloseMultiple(c *C) {
-	// Test calling Close multiple times
-	dbPath := filepath.Join(s.tempDir, "close-multiple")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// First close should work
-	err = db.Close()
-	c.Check(err, IsNil)
-	
-	// Second close should not error
-	err = db.Close()
-	c.Check(err, IsNil)
-	
-	// Third close should not error
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestStorageOpenMultiple(c *C) {
-	// Test calling Open multiple times
-	dbPath := filepath.Join(s.tempDir, "open-multiple")
-	
-	db, err := goleveldb.NewDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// First open should work
-	err = db.Open()
-	c.Check(err, IsNil)
-	
-	// Second open should not error (already open)
-	err = db.Open()
-	c.Check(err, IsNil)
-	
-	// Should still be functional
-	err = db.Put([]byte("test"), []byte("value"))
-	c.Check(err, IsNil)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestStorageDropError(c *C) {
-	// Test Drop when database is still open
-	dbPath := filepath.Join(s.tempDir, "drop-error")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Try to drop while DB is open (should error)
-	err = db.Drop()
-	c.Check(err, NotNil)
-	c.Check(err.Error(), Equals, "DB is still open")
-	
-	// Close and then drop should work
-	err = db.Close()
-	c.Check(err, IsNil)
-	
-	err = db.Drop()
-	c.Check(err, IsNil)
-	
-	// Verify directory is gone
-	_, err = os.Stat(dbPath)
-	c.Check(os.IsNotExist(err), Equals, true)
-}
-
-func (s *ExtendedLevelDBSuite) TestTransactionInterface(c *C) {
-	// Test transaction functionality
-	dbPath := filepath.Join(s.tempDir, "transaction-test")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Create transaction
-	tx, err := db.OpenTransaction()
-	c.Check(err, IsNil)
-	c.Check(tx, NotNil)
-	
-	// Test transaction operations
-	key := []byte("tx-key")
-	value := []byte("tx-value")
-	
-	err = tx.Put(key, value)
-	c.Check(err, IsNil)
-	
-	// Value should not be visible outside transaction yet
-	_, err = db.Get(key)
-	c.Check(err, Equals, database.ErrNotFound)
-	
-	// But should be visible within transaction
-	txValue, err := tx.Get(key)
-	c.Check(err, IsNil)
-	c.Check(txValue, DeepEquals, value)
-	
-	// Commit transaction
-	err = tx.Commit()
-	c.Check(err, IsNil)
-	
-	// Now value should be visible
-	finalValue, err := db.Get(key)
-	c.Check(err, IsNil)
-	c.Check(finalValue, DeepEquals, value)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestTransactionDiscard(c *C) {
-	// Test transaction discard functionality
-	dbPath := filepath.Join(s.tempDir, "transaction-discard")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Create transaction
-	tx, err := db.OpenTransaction()
-	c.Check(err, IsNil)
-	
-	key := []byte("discard-key")
-	value := []byte("discard-value")
-	
-	err = tx.Put(key, value)
-	c.Check(err, IsNil)
-	
-	// Discard transaction
-	tx.Discard()
-	
-	// Value should not be visible
-	_, err = db.Get(key)
-	c.Check(err, Equals, database.ErrNotFound)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestProcessByPrefixError(c *C) {
-	// Test ProcessByPrefix with processor that returns error
-	dbPath := filepath.Join(s.tempDir, "process-error")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Add some data
-	prefix := []byte("error-")
-	err = db.Put(append(prefix, []byte("key1")...), []byte("value1"))
-	c.Check(err, IsNil)
-	err = db.Put(append(prefix, []byte("key2")...), []byte("value2"))
-	c.Check(err, IsNil)
-	
-	// Process with error-returning function
-	testError := errors.New("processing error")
-	processedCount := 0
-	
-	err = db.ProcessByPrefix(prefix, func(key, value []byte) error {
-		processedCount++
-		if processedCount == 1 {
-			return testError
-		}
-		return nil
-	})
-	
-	c.Check(err, Equals, testError)
-	c.Check(processedCount, Equals, 1) // Should stop at first error
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestPrefixOperationsEmptyDB(c *C) {
-	// Test prefix operations on empty database
-	dbPath := filepath.Join(s.tempDir, "empty-prefix")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	prefix := []byte("empty")
-	
-	// All prefix operations should return empty results
-	c.Check(db.HasPrefix(prefix), Equals, false)
-	c.Check(db.KeysByPrefix(prefix), DeepEquals, [][]byte{})
-	c.Check(db.FetchByPrefix(prefix), DeepEquals, [][]byte{})
-	
-	processedCount := 0
-	err = db.ProcessByPrefix(prefix, func(key, value []byte) error {
-		processedCount++
-		return nil
-	})
-	c.Check(err, IsNil)
-	c.Check(processedCount, Equals, 0)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestBatchOperations(c *C) {
-	// Test batch operations in detail
-	dbPath := filepath.Join(s.tempDir, "batch-ops")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Create batch
-	batch := db.CreateBatch()
-	c.Check(batch, NotNil)
-	
-	// Add multiple operations to batch
-	keys := [][]byte{
-		[]byte("batch-key-1"),
-		[]byte("batch-key-2"),
-		[]byte("batch-key-3"),
-	}
-	values := [][]byte{
-		[]byte("batch-value-1"),
-		[]byte("batch-value-2"),
-		[]byte("batch-value-3"),
-	}
-	
-	for i, key := range keys {
-		err = batch.Put(key, values[i])
-		c.Check(err, IsNil)
-	}
-	
-	// Values should not be visible before Write
-	for _, key := range keys {
-		_, err = db.Get(key)
-		c.Check(err, Equals, database.ErrNotFound)
-	}
-	
-	// Write batch
-	err = batch.Write()
-	c.Check(err, IsNil)
-	
-	// Now all values should be visible
-	for i, key := range keys {
-		value, err := db.Get(key)
-		c.Check(err, IsNil)
-		c.Check(value, DeepEquals, values[i])
-	}
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestIteratorEdgeCases(c *C) {
-	// Test iterator edge cases in prefix operations
-	dbPath := filepath.Join(s.tempDir, "iterator-edge")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Add data with similar but different prefixes
-	prefixes := [][]byte{
-		[]byte("test"),
-		[]byte("test-"),
-		[]byte("test-a"),
-		[]byte("test-ab"),
-		[]byte("testing"),
-		[]byte("totally-different"),
-	}
-	
-	for i, prefix := range prefixes {
-		key := append(prefix, []byte("key")...)
-		value := []byte{byte(i)}
-		err = db.Put(key, value)
-		c.Check(err, IsNil)
-	}
-	
-	// Test exact prefix matching
-	targetPrefix := []byte("test-")
-	keys := db.KeysByPrefix(targetPrefix)
-	values := db.FetchByPrefix(targetPrefix)
-	
-	// Should only match keys that start with "test-"
-	expectedCount := 0
-	for _, prefix := range prefixes {
-		testKey := append(prefix, []byte("key")...)
-		if len(testKey) >= len(targetPrefix) {
-			if string(testKey[:len(targetPrefix)]) == string(targetPrefix) {
-				expectedCount++
-			}
-		}
-	}
-	
-	c.Check(len(keys), Equals, expectedCount)
-	c.Check(len(values), Equals, expectedCount)
-	
-	err = db.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestCompactDBError(c *C) {
-	// Test CompactDB on closed database
-	dbPath := filepath.Join(s.tempDir, "compact-error")
-	
-	db, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	
-	// Close database
-	err = db.Close()
-	c.Check(err, IsNil)
-	
-	// CompactDB should error on closed database
-	err = db.CompactDB()
-	c.Check(err, NotNil)
-}
-
-func (s *ExtendedLevelDBSuite) TestInterface(c *C) {
-	// Test that storage implements database.Storage interface
-	dbPath := filepath.Join(s.tempDir, "interface-test")
-	
-	var storage database.Storage
-	storage, err := goleveldb.NewOpenDB(dbPath)
-	c.Check(err, IsNil)
-	c.Check(storage, NotNil)
-	
-	// Test that all interface methods are available
-	_, err = storage.Get([]byte("test"))
-	c.Check(err, Equals, database.ErrNotFound)
-	
-	err = storage.Put([]byte("test"), []byte("value"))
-	c.Check(err, IsNil)
-	
-	err = storage.Delete([]byte("test"))
-	c.Check(err, IsNil)
-	
-	c.Check(storage.HasPrefix([]byte("test")), Equals, false)
-	c.Check(storage.KeysByPrefix([]byte("test")), DeepEquals, [][]byte{})
-	c.Check(storage.FetchByPrefix([]byte("test")), DeepEquals, [][]byte{})
-	
-	err = storage.ProcessByPrefix([]byte("test"), func(k, v []byte) error { return nil })
-	c.Check(err, IsNil)
-	
-	batch := storage.CreateBatch()
-	c.Check(batch, NotNil)
-	
-	tx, err := storage.OpenTransaction()
-	c.Check(err, IsNil)
-	c.Check(tx, NotNil)
-	tx.Discard()
-	
-	temp, err := storage.CreateTemporary()
-	c.Check(err, IsNil)
-	c.Check(temp, NotNil)
-	temp.Close()
-	temp.Drop()
-	
-	err = storage.CompactDB()
-	c.Check(err, IsNil)
-	
-	err = storage.Close()
-	c.Check(err, IsNil)
-	
-	err = storage.Drop()
-	c.Check(err, IsNil)
-}

database/goleveldb/storage_race_test.go

@@ -1,270 +0,0 @@
-package goleveldb
-
-import (
-	"fmt"
-	"os"
-	"sync"
-	"testing"
-	"time"
-)
-
-// Test for database close race condition
-func TestStorageCloseRace(t *testing.T) {
-	// Create temporary storage
-	tempdir, err := os.MkdirTemp("", "aptly-race-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tempdir)
-	
-	db, err := internalOpen(tempdir, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	
-	storage := &storage{db: db, path: tempdir}
-	
-	// Put some initial data
-	err = storage.Put([]byte("test-key"), []byte("test-value"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	
-	var wg sync.WaitGroup
-	errors := make(chan error, 100)
-	panics := make(chan string, 100)
-	
-	// Start multiple goroutines doing database operations
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			defer func() {
-				if r := recover(); r != nil {
-					panics <- fmt.Sprintf("goroutine %d panicked: %v", id, r)
-				}
-			}()
-			
-			// Continuously perform operations
-			for j := 0; j < 100; j++ {
-				// Try Get operation
-				_, err := storage.Get([]byte("test-key"))
-				if err != nil && err.Error() != "database is nil" {
-					errors <- fmt.Errorf("get error in goroutine %d: %v", id, err)
-					return
-				}
-				
-				// Try Put operation
-				err = storage.Put([]byte(fmt.Sprintf("key-%d-%d", id, j)), []byte("value"))
-				if err != nil && err.Error() != "database is nil" {
-					errors <- fmt.Errorf("put error in goroutine %d: %v", id, err)
-					return
-				}
-				
-				// Small delay to increase race window
-				time.Sleep(time.Microsecond)
-			}
-		}(i)
-	}
-	
-	// Start goroutines that close the database
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			defer func() {
-				if r := recover(); r != nil {
-					panics <- fmt.Sprintf("close goroutine %d panicked: %v", id, r)
-				}
-			}()
-			
-			// Wait a bit then close
-			time.Sleep(time.Duration(id*10) * time.Millisecond)
-			err := storage.Close()
-			if err != nil {
-				errors <- fmt.Errorf("close error in goroutine %d: %v", id, err)
-			}
-		}(i)
-	}
-	
-	wg.Wait()
-	close(errors)
-	close(panics)
-	
-	// Check for panics (indicates race condition bug)
-	for panic := range panics {
-		t.Errorf("Race condition caused panic: %s", panic)
-	}
-	
-	// Some errors are expected (database closed), but panics are not
-	errorCount := 0
-	for err := range errors {
-		errorCount++
-		if errorCount < 10 { // Only log first few errors
-			t.Logf("Expected error during race: %v", err)
-		}
-	}
-}
-
-// Test concurrent operations vs close
-func TestStorageConcurrentOpsVsClose(t *testing.T) {
-	for attempt := 0; attempt < 5; attempt++ {
-		// Create fresh storage for each attempt
-		tempdir, err := os.MkdirTemp("", "aptly-concurrent-test")
-		if err != nil {
-			t.Fatal(err)
-		}
-		defer os.RemoveAll(tempdir)
-		
-		db, err := internalOpen(tempdir, true)
-		if err != nil {
-			t.Fatal(err)
-		}
-		
-		storage := &storage{db: db, path: tempdir}
-		
-		var wg sync.WaitGroup
-		panicked := make(chan bool, 1)
-		
-		// Goroutine performing operations
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			defer func() {
-				if r := recover(); r != nil {
-					panicked <- true
-				}
-			}()
-			
-			for i := 0; i < 1000; i++ {
-				storage.Get([]byte("key"))
-				storage.Put([]byte("key"), []byte("value"))
-				storage.Delete([]byte("key"))
-			}
-		}()
-		
-		// Goroutine closing database
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			time.Sleep(50 * time.Millisecond) // Let operations start
-			storage.Close()
-		}()
-		
-		wg.Wait()
-		
-		// Check if panic occurred
-		select {
-		case <-panicked:
-			t.Errorf("Attempt %d: Panic occurred during concurrent ops vs close", attempt)
-		default:
-			// No panic - good
-		}
-		
-		close(panicked)
-	}
-}
-
-// Test multiple concurrent close attempts
-func TestStorageMultipleClose(t *testing.T) {
-	tempdir, err := os.MkdirTemp("", "aptly-close-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tempdir)
-	
-	db, err := internalOpen(tempdir, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	
-	storage := &storage{db: db, path: tempdir}
-	
-	var wg sync.WaitGroup
-	panics := make(chan string, 20)
-	
-	// Multiple goroutines trying to close
-	for i := 0; i < 20; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			defer func() {
-				if r := recover(); r != nil {
-					panics <- fmt.Sprintf("close %d panicked: %v", id, r)
-				}
-			}()
-			
-			err := storage.Close()
-			if err != nil {
-				// Error is ok, panic is not
-				t.Logf("Close %d got error (expected): %v", id, err)
-			}
-		}(i)
-	}
-	
-	wg.Wait()
-	close(panics)
-	
-	// Check for panics
-	for panic := range panics {
-		t.Errorf("Multiple close caused panic: %s", panic)
-	}
-}
-
-// Test iterator operations during close
-func TestStorageIteratorRace(t *testing.T) {
-	tempdir, err := os.MkdirTemp("", "aptly-iterator-test")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(tempdir)
-	
-	db, err := internalOpen(tempdir, true)
-	if err != nil {
-		t.Fatal(err)
-	}
-	
-	storage := &storage{db: db, path: tempdir}
-	
-	// Add some data
-	for i := 0; i < 100; i++ {
-		storage.Put([]byte(fmt.Sprintf("key-%03d", i)), []byte("value"))
-	}
-	
-	var wg sync.WaitGroup
-	panics := make(chan string, 10)
-	
-	// Goroutines using iterators
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			defer func() {
-				if r := recover(); r != nil {
-					panics <- fmt.Sprintf("iterator %d panicked: %v", id, r)
-				}
-			}()
-			
-			// Use methods that create iterators
-			storage.KeysByPrefix([]byte("key-"))
-			storage.FetchByPrefix([]byte("key-"))
-			storage.HasPrefix([]byte("key-"))
-		}(i)
-	}
-	
-	// Close database while iterators are running
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		time.Sleep(10 * time.Millisecond)
-		storage.Close()
-	}()
-	
-	wg.Wait()
-	close(panics)
-	
-	// Check for panics
-	for panic := range panics {
-		t.Errorf("Iterator race caused panic: %s", panic)
-	}
-}

database/goleveldb/storage_test.go

@@ -1,121 +0,0 @@
-package goleveldb
-
-import (
-	"github.com/aptly-dev/aptly/database"
-	. "gopkg.in/check.v1"
-)
-
-type LevelDBStorageSuite struct {
-	storage *storage
-	tempDir string
-}
-
-var _ = Suite(&LevelDBStorageSuite{})
-
-func (s *LevelDBStorageSuite) SetUpTest(c *C) {
-	s.tempDir = c.MkDir()
-	s.storage = &storage{
-		path: s.tempDir,
-		db:   nil, // Not opened for unit tests
-	}
-}
-
-func (s *LevelDBStorageSuite) TestCreateTemporary(c *C) {
-	// Test creating temporary storage
-	tempStorage, err := s.storage.CreateTemporary()
-	if err != nil {
-		// Expected to fail without real leveldb setup
-		c.Check(err, NotNil)
-		return
-	}
-	
-	c.Check(tempStorage, NotNil)
-	levelStorage, ok := tempStorage.(*storage)
-	c.Check(ok, Equals, true)
-	c.Check(len(levelStorage.path) > 0, Equals, true)
-	c.Check(levelStorage.path, Not(Equals), s.storage.path)
-}
-
-func (s *LevelDBStorageSuite) TestCloseNilDB(c *C) {
-	// Test closing storage with nil DB
-	err := s.storage.Close()
-	c.Check(err, IsNil)
-}
-
-func (s *LevelDBStorageSuite) TestOpenNilDB(c *C) {
-	// Test opening storage - should succeed with valid path
-	err := s.storage.Open()
-	// Should succeed with valid temporary directory
-	c.Check(err, IsNil)
-	// Clean up
-	s.storage.Close()
-}
-
-func (s *LevelDBStorageSuite) TestCreateBatchNilDB(c *C) {
-	// Test creating batch with nil DB
-	batch := s.storage.CreateBatch()
-	c.Check(batch, IsNil)
-}
-
-func (s *LevelDBStorageSuite) TestCompactDB(c *C) {
-	// Test CompactDB with nil DB - should handle gracefully
-	err := s.storage.CompactDB()
-	c.Check(err, NotNil) // Expected to fail with nil DB
-}
-
-func (s *LevelDBStorageSuite) TestDropNilDB(c *C) {
-	// Test dropping storage with nil DB
-	err := s.storage.Drop()
-	c.Check(err, IsNil) // Should succeed (removes directory)
-}
-
-func (s *LevelDBStorageSuite) TestInterfaceCompliance(c *C) {
-	// Test that storage implements database.Storage interface
-	var dbStorage database.Storage = &storage{}
-	c.Check(dbStorage, NotNil)
-}
-
-func (s *LevelDBStorageSuite) TestGetNilDB(c *C) {
-	// Test Get with nil DB - should fail
-	_, err := s.storage.Get([]byte("key"))
-	c.Check(err, NotNil) // Expected to fail with nil DB
-}
-
-// Note: storage does not implement Has method - it uses Get and checks for ErrNotFound
-
-func (s *LevelDBStorageSuite) TestPutNilDB(c *C) {
-	// Test Put with nil DB - should fail
-	err := s.storage.Put([]byte("key"), []byte("value"))
-	c.Check(err, NotNil) // Expected to fail with nil DB
-}
-
-func (s *LevelDBStorageSuite) TestDeleteNilDB(c *C) {
-	// Test Delete with nil DB - should fail
-	err := s.storage.Delete([]byte("key"))
-	c.Check(err, NotNil) // Expected to fail with nil DB
-}
-
-func (s *LevelDBStorageSuite) TestKeysByPrefixNilDB(c *C) {
-	// Test KeysByPrefix with nil DB - should return nil
-	keys := s.storage.KeysByPrefix([]byte("prefix/"))
-	c.Check(keys, IsNil)
-}
-
-func (s *LevelDBStorageSuite) TestFetchByPrefixNilDB(c *C) {
-	// Test FetchByPrefix with nil DB - should return nil
-	values := s.storage.FetchByPrefix([]byte("prefix/"))
-	c.Check(values, IsNil)
-}
-
-func (s *LevelDBStorageSuite) TestHasPrefixNilDB(c *C) {
-	// Test HasPrefix with nil DB - should return false
-	result := s.storage.HasPrefix([]byte("prefix/"))
-	c.Check(result, Equals, false)
-}
-
-func (s *LevelDBStorageSuite) TestProcessByPrefixNilDB(c *C) {
-	// Test ProcessByPrefix with nil DB - should fail
-	processor := func(key, value []byte) error { return nil }
-	err := s.storage.ProcessByPrefix([]byte("prefix/"), processor)
-	c.Check(err, NotNil) // Expected to fail with nil DB
-}

database/goleveldb/transaction_test.go

@@ -1,38 +0,0 @@
-package goleveldb
-
-import (
-	"github.com/aptly-dev/aptly/database"
-	. "gopkg.in/check.v1"
-)
-
-type TransactionSuite struct {
-	storage *storage
-	tempDir string
-}
-
-var _ = Suite(&TransactionSuite{})
-
-func (s *TransactionSuite) SetUpTest(c *C) {
-	s.tempDir = c.MkDir()
-	s.storage = &storage{
-		path: s.tempDir,
-		db:   nil, // Not opened for unit tests
-	}
-}
-
-func (s *TransactionSuite) TestOpenTransactionNilDB(c *C) {
-	// Test opening transaction with nil DB - should fail
-	transaction, err := s.storage.OpenTransaction()
-	c.Check(err, NotNil) // Expected to fail with nil DB
-	c.Check(transaction, IsNil)
-}
-
-func (s *TransactionSuite) TestInterfaceCompliance(c *C) {
-	// Test that storage implements the transaction interface
-	var storageInterface database.Storage = &storage{}
-	c.Check(storageInterface, NotNil)
-	
-	// Test that we can call OpenTransaction method
-	_, err := storageInterface.OpenTransaction()
-	c.Check(err, NotNil) // Expected to fail without proper setup
-}