mirror of
https://github.com/lukaszraczylo/graphql-monitoring-proxy.git
synced 2026-10-18 06:17:56 +00:00
Gofmt the codebase.
This commit is contained in:
Vendored
+60
-60
@@ -16,7 +16,7 @@ func (suite *Tests) Test_CalculateHash() {
|
||||
app := fiber.New()
|
||||
ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
|
||||
defer app.ReleaseCtx(ctx)
|
||||
|
||||
|
||||
// Test with empty body
|
||||
suite.Run("empty body", func() {
|
||||
ctx.Request().SetBody([]byte(""))
|
||||
@@ -24,7 +24,7 @@ func (suite *Tests) Test_CalculateHash() {
|
||||
assert.NotEmpty(hash)
|
||||
assert.Equal(32, len(hash)) // MD5 hash is 32 characters
|
||||
})
|
||||
|
||||
|
||||
// Test with non-empty body
|
||||
suite.Run("non-empty body", func() {
|
||||
ctx.Request().SetBody([]byte("test body"))
|
||||
@@ -32,15 +32,15 @@ func (suite *Tests) Test_CalculateHash() {
|
||||
assert.NotEmpty(hash)
|
||||
assert.Equal(32, len(hash))
|
||||
})
|
||||
|
||||
|
||||
// Test with different bodies produce different hashes
|
||||
suite.Run("different bodies", func() {
|
||||
ctx.Request().SetBody([]byte("body1"))
|
||||
hash1 := CalculateHash(ctx)
|
||||
|
||||
|
||||
ctx.Request().SetBody([]byte("body2"))
|
||||
hash2 := CalculateHash(ctx)
|
||||
|
||||
|
||||
assert.NotEqual(hash1, hash2)
|
||||
})
|
||||
}
|
||||
@@ -52,43 +52,43 @@ func (suite *Tests) Test_CacheDelete() {
|
||||
Client: libpack_cache_memory.New(5 * time.Minute),
|
||||
TTL: 5,
|
||||
}
|
||||
|
||||
|
||||
// Test deleting a cache entry
|
||||
suite.Run("delete existing entry", func() {
|
||||
// Add an entry to cache
|
||||
testKey := "test-delete-key"
|
||||
testValue := []byte("test-delete-value")
|
||||
CacheStore(testKey, testValue)
|
||||
|
||||
|
||||
// Verify it was added
|
||||
result := CacheLookup(testKey)
|
||||
assert.Equal(testValue, result)
|
||||
|
||||
|
||||
// Delete the entry
|
||||
CacheDelete(testKey)
|
||||
|
||||
|
||||
// Verify it was deleted
|
||||
result = CacheLookup(testKey)
|
||||
assert.Nil(result)
|
||||
})
|
||||
|
||||
|
||||
// Test deleting a non-existent entry
|
||||
suite.Run("delete non-existent entry", func() {
|
||||
// This should not cause any errors
|
||||
CacheDelete("non-existent-key")
|
||||
})
|
||||
|
||||
|
||||
// Test with uninitialized cache
|
||||
suite.Run("uninitialized cache", func() {
|
||||
// Save current config
|
||||
oldConfig := config
|
||||
|
||||
|
||||
// Set config to nil
|
||||
config = nil
|
||||
|
||||
|
||||
// This should not cause any errors
|
||||
CacheDelete("any-key")
|
||||
|
||||
|
||||
// Restore config
|
||||
config = oldConfig
|
||||
})
|
||||
@@ -101,38 +101,38 @@ func (suite *Tests) Test_CacheStoreWithTTL() {
|
||||
Client: libpack_cache_memory.New(5 * time.Minute),
|
||||
TTL: 5,
|
||||
}
|
||||
|
||||
|
||||
// Test storing with custom TTL
|
||||
suite.Run("store with custom TTL", func() {
|
||||
testKey := "test-ttl-key"
|
||||
testValue := []byte("test-ttl-value")
|
||||
customTTL := 1 * time.Second
|
||||
|
||||
|
||||
CacheStoreWithTTL(testKey, testValue, customTTL)
|
||||
|
||||
|
||||
// Verify it was stored
|
||||
result := CacheLookup(testKey)
|
||||
assert.Equal(testValue, result)
|
||||
|
||||
|
||||
// Wait for TTL to expire
|
||||
time.Sleep(1100 * time.Millisecond)
|
||||
|
||||
|
||||
// Verify it was removed
|
||||
result = CacheLookup(testKey)
|
||||
assert.Nil(result)
|
||||
})
|
||||
|
||||
|
||||
// Test with uninitialized cache
|
||||
suite.Run("uninitialized cache", func() {
|
||||
// Save current config
|
||||
oldConfig := config
|
||||
|
||||
|
||||
// Set config to nil
|
||||
config = nil
|
||||
|
||||
|
||||
// This should not cause any errors
|
||||
CacheStoreWithTTL("any-key", []byte("any-value"), 1*time.Second)
|
||||
|
||||
|
||||
// Restore config
|
||||
config = oldConfig
|
||||
})
|
||||
@@ -145,33 +145,33 @@ func (suite *Tests) Test_CacheGetQueries() {
|
||||
Client: libpack_cache_memory.New(5 * time.Minute),
|
||||
TTL: 5,
|
||||
}
|
||||
|
||||
|
||||
// Test getting query count
|
||||
suite.Run("get query count", func() {
|
||||
// Clear cache
|
||||
CacheClear()
|
||||
|
||||
|
||||
// Add some entries
|
||||
CacheStore("test-key-1", []byte("test-value-1"))
|
||||
CacheStore("test-key-2", []byte("test-value-2"))
|
||||
|
||||
|
||||
// Get query count
|
||||
count := CacheGetQueries()
|
||||
assert.Equal(int64(2), count)
|
||||
})
|
||||
|
||||
|
||||
// Test with uninitialized cache
|
||||
suite.Run("uninitialized cache", func() {
|
||||
// Save current config
|
||||
oldConfig := config
|
||||
|
||||
|
||||
// Set config to nil
|
||||
config = nil
|
||||
|
||||
|
||||
// This should return 0
|
||||
count := CacheGetQueries()
|
||||
assert.Equal(int64(0), count)
|
||||
|
||||
|
||||
// Restore config
|
||||
config = oldConfig
|
||||
})
|
||||
@@ -184,34 +184,34 @@ func (suite *Tests) Test_CacheClear() {
|
||||
Client: libpack_cache_memory.New(5 * time.Minute),
|
||||
TTL: 5,
|
||||
}
|
||||
|
||||
|
||||
// Create a new CacheStats instance
|
||||
cacheStats = &CacheStats{
|
||||
CachedQueries: 0,
|
||||
CacheHits: 0,
|
||||
CacheMisses: 0,
|
||||
}
|
||||
|
||||
|
||||
// Test clearing cache
|
||||
suite.Run("clear cache", func() {
|
||||
// Add some entries
|
||||
CacheStore("test-key-1", []byte("test-value-1"))
|
||||
CacheStore("test-key-2", []byte("test-value-2"))
|
||||
|
||||
|
||||
// Verify they were added
|
||||
assert.NotNil(CacheLookup("test-key-1"))
|
||||
assert.NotNil(CacheLookup("test-key-2"))
|
||||
|
||||
|
||||
// Get the current stats before clearing
|
||||
beforeStats := GetCacheStats()
|
||||
|
||||
|
||||
// Clear cache
|
||||
CacheClear()
|
||||
|
||||
|
||||
// Verify cache was cleared
|
||||
assert.Nil(CacheLookup("test-key-1"))
|
||||
assert.Nil(CacheLookup("test-key-2"))
|
||||
|
||||
|
||||
// Verify stats were reset
|
||||
afterStats := GetCacheStats()
|
||||
assert.Equal(int64(0), afterStats.CachedQueries)
|
||||
@@ -227,39 +227,39 @@ func (suite *Tests) Test_GetCacheStats() {
|
||||
TTL: 5,
|
||||
}
|
||||
cacheStats = &CacheStats{}
|
||||
|
||||
|
||||
// Test getting cache stats
|
||||
suite.Run("get cache stats", func() {
|
||||
// Clear cache
|
||||
CacheClear()
|
||||
|
||||
|
||||
// Add some entries and perform lookups
|
||||
CacheStore("test-key-1", []byte("test-value-1"))
|
||||
CacheStore("test-key-2", []byte("test-value-2"))
|
||||
CacheLookup("test-key-1") // Hit
|
||||
CacheLookup("test-key-3") // Miss
|
||||
|
||||
|
||||
// Get stats
|
||||
stats := GetCacheStats()
|
||||
assert.Equal(int64(2), stats.CachedQueries)
|
||||
assert.Equal(int64(1), stats.CacheHits)
|
||||
assert.Equal(int64(1), stats.CacheMisses)
|
||||
})
|
||||
|
||||
|
||||
// Test with uninitialized cache
|
||||
suite.Run("uninitialized cache", func() {
|
||||
// Save current config
|
||||
oldConfig := config
|
||||
|
||||
|
||||
// Set config to nil
|
||||
config = nil
|
||||
|
||||
|
||||
// This should return empty stats
|
||||
stats := GetCacheStats()
|
||||
assert.Equal(int64(0), stats.CachedQueries)
|
||||
assert.Equal(int64(0), stats.CacheHits)
|
||||
assert.Equal(int64(0), stats.CacheMisses)
|
||||
|
||||
|
||||
// Restore config
|
||||
config = oldConfig
|
||||
})
|
||||
@@ -272,12 +272,12 @@ func (suite *Tests) Test_CacheLookup_Compressed() {
|
||||
Client: libpack_cache_memory.New(5 * time.Minute),
|
||||
TTL: 5,
|
||||
}
|
||||
|
||||
|
||||
// Test lookup with compressed data
|
||||
suite.Run("lookup compressed data", func() {
|
||||
testKey := "test-compressed-key"
|
||||
testValue := []byte("test-compressed-value")
|
||||
|
||||
|
||||
// Compress the data
|
||||
var buf bytes.Buffer
|
||||
gzWriter := gzip.NewWriter(&buf)
|
||||
@@ -286,15 +286,15 @@ func (suite *Tests) Test_CacheLookup_Compressed() {
|
||||
err = gzWriter.Close()
|
||||
assert.NoError(err)
|
||||
compressedData := buf.Bytes()
|
||||
|
||||
|
||||
// Store compressed data directly
|
||||
config.Client.Set(testKey, compressedData, time.Duration(config.TTL)*time.Second)
|
||||
|
||||
|
||||
// Lookup should automatically decompress
|
||||
result := CacheLookup(testKey)
|
||||
assert.Equal(testValue, result)
|
||||
})
|
||||
|
||||
|
||||
// Skip the invalid compressed data test as it's causing issues
|
||||
// We'll mock the behavior instead
|
||||
suite.Run("lookup invalid compressed data", func() {
|
||||
@@ -313,16 +313,16 @@ func (suite *Tests) Test_ShouldUseRedisCache() {
|
||||
suite.Run("redis enabled", func() {
|
||||
cfg := &CacheConfig{}
|
||||
cfg.Redis.Enable = true
|
||||
|
||||
|
||||
result := ShouldUseRedisCache(cfg)
|
||||
assert.True(result)
|
||||
})
|
||||
|
||||
|
||||
// Test with Redis disabled
|
||||
suite.Run("redis disabled", func() {
|
||||
cfg := &CacheConfig{}
|
||||
cfg.Redis.Enable = false
|
||||
|
||||
|
||||
result := ShouldUseRedisCache(cfg)
|
||||
assert.False(result)
|
||||
})
|
||||
@@ -335,22 +335,22 @@ func (suite *Tests) Test_IsCacheInitialized() {
|
||||
Logger: libpack_logger.New(),
|
||||
Client: libpack_cache_memory.New(5 * time.Minute),
|
||||
}
|
||||
|
||||
|
||||
result := IsCacheInitialized()
|
||||
assert.True(result)
|
||||
})
|
||||
|
||||
|
||||
// Test with nil config
|
||||
suite.Run("nil config", func() {
|
||||
oldConfig := config
|
||||
config = nil
|
||||
|
||||
|
||||
result := IsCacheInitialized()
|
||||
assert.False(result)
|
||||
|
||||
|
||||
config = oldConfig
|
||||
})
|
||||
|
||||
|
||||
// Test with nil client
|
||||
suite.Run("nil client", func() {
|
||||
oldConfig := config
|
||||
@@ -358,10 +358,10 @@ func (suite *Tests) Test_IsCacheInitialized() {
|
||||
Logger: libpack_logger.New(),
|
||||
Client: nil,
|
||||
}
|
||||
|
||||
|
||||
result := IsCacheInitialized()
|
||||
assert.False(result)
|
||||
|
||||
|
||||
config = oldConfig
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
Vendored
+14
-14
@@ -17,8 +17,8 @@ const CompressionThreshold = 1024 // 1KB
|
||||
const MaxCacheSize = 10000
|
||||
|
||||
type CacheEntry struct {
|
||||
ExpiresAt time.Time
|
||||
Value []byte
|
||||
ExpiresAt time.Time
|
||||
Value []byte
|
||||
Compressed bool
|
||||
}
|
||||
|
||||
@@ -59,7 +59,7 @@ func (c *Cache) cleanupRoutine(globalTTL time.Duration) {
|
||||
|
||||
for range ticker.C {
|
||||
c.CleanExpiredEntries()
|
||||
|
||||
|
||||
// Trigger GC if we have a lot of entries
|
||||
if atomic.LoadInt64(&c.entryCount) > MaxCacheSize/2 {
|
||||
runtime.GC()
|
||||
@@ -74,7 +74,7 @@ func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
|
||||
}
|
||||
|
||||
expiresAt := time.Now().Add(ttl)
|
||||
|
||||
|
||||
// Only compress if the value is larger than the threshold
|
||||
var entry CacheEntry
|
||||
if len(value) > CompressionThreshold {
|
||||
@@ -100,13 +100,13 @@ func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
|
||||
Compressed: false,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Check if this is a new entry
|
||||
_, exists := c.entries.Load(key)
|
||||
if !exists {
|
||||
atomic.AddInt64(&c.entryCount, 1)
|
||||
}
|
||||
|
||||
|
||||
c.entries.Store(key, entry)
|
||||
}
|
||||
|
||||
@@ -130,7 +130,7 @@ func (c *Cache) Get(key string) ([]byte, bool) {
|
||||
}
|
||||
return value, true
|
||||
}
|
||||
|
||||
|
||||
return cacheEntry.Value, true
|
||||
}
|
||||
|
||||
@@ -156,7 +156,7 @@ func (c *Cache) compress(data []byte) ([]byte, error) {
|
||||
var buf bytes.Buffer
|
||||
w := c.compressPool.Get().(*gzip.Writer)
|
||||
defer c.compressPool.Put(w)
|
||||
|
||||
|
||||
w.Reset(&buf)
|
||||
if _, err := w.Write(data); err != nil {
|
||||
return nil, err
|
||||
@@ -170,7 +170,7 @@ func (c *Cache) compress(data []byte) ([]byte, error) {
|
||||
func (c *Cache) decompress(data []byte) ([]byte, error) {
|
||||
r, ok := c.decompressPool.Get().(*gzip.Reader)
|
||||
defer c.decompressPool.Put(r)
|
||||
|
||||
|
||||
if !ok || r == nil {
|
||||
var err error
|
||||
r, err = gzip.NewReader(bytes.NewReader(data))
|
||||
@@ -182,7 +182,7 @@ func (c *Cache) decompress(data []byte) ([]byte, error) {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
defer r.Close()
|
||||
return io.ReadAll(r)
|
||||
}
|
||||
@@ -203,10 +203,10 @@ func (c *Cache) CleanExpiredEntries() {
|
||||
// evictOldest removes the oldest n entries from the cache
|
||||
func (c *Cache) evictOldest(n int) {
|
||||
type keyExpiry struct {
|
||||
key string
|
||||
key string
|
||||
expiresAt time.Time
|
||||
}
|
||||
|
||||
|
||||
// Collect all entries with their expiry times
|
||||
entries := make([]keyExpiry, 0, n*2)
|
||||
c.entries.Range(func(k, v interface{}) bool {
|
||||
@@ -215,7 +215,7 @@ func (c *Cache) evictOldest(n int) {
|
||||
entries = append(entries, keyExpiry{key, entry.ExpiresAt})
|
||||
return len(entries) < cap(entries)
|
||||
})
|
||||
|
||||
|
||||
// Sort by expiry time (oldest first)
|
||||
// Using a simple selection sort since we only need to find the n oldest
|
||||
for i := 0; i < n && i < len(entries); i++ {
|
||||
@@ -229,7 +229,7 @@ func (c *Cache) evictOldest(n int) {
|
||||
if oldest != i {
|
||||
entries[i], entries[oldest] = entries[oldest], entries[i]
|
||||
}
|
||||
|
||||
|
||||
// Delete this entry
|
||||
if _, exists := c.entries.LoadAndDelete(entries[i].key); exists {
|
||||
atomic.AddInt64(&c.entryCount, -1)
|
||||
|
||||
+19
-19
@@ -14,45 +14,45 @@ const (
|
||||
|
||||
func TestMemoryCacheClear(t *testing.T) {
|
||||
cache := New(DefaultTestExpiration)
|
||||
|
||||
|
||||
// Add some entries
|
||||
cache.Set("key1", []byte("value1"), DefaultTestExpiration)
|
||||
cache.Set("key2", []byte("value2"), DefaultTestExpiration)
|
||||
|
||||
|
||||
// Verify entries exist
|
||||
_, found := cache.Get("key1")
|
||||
assert.True(t, found, "Expected key1 to exist before clearing cache")
|
||||
|
||||
|
||||
// Clear the cache
|
||||
cache.Clear()
|
||||
|
||||
|
||||
// Verify cache is empty
|
||||
_, found = cache.Get("key1")
|
||||
assert.False(t, found, "Expected key1 to be removed after clearing cache")
|
||||
_, found = cache.Get("key2")
|
||||
assert.False(t, found, "Expected key2 to be removed after clearing cache")
|
||||
|
||||
|
||||
// Check that counter was reset
|
||||
assert.Equal(t, int64(0), cache.CountQueries(), "Expected count to be 0 after clearing cache")
|
||||
}
|
||||
|
||||
func TestMemoryCacheCountQueries(t *testing.T) {
|
||||
cache := New(DefaultTestExpiration)
|
||||
|
||||
|
||||
// Check initial count
|
||||
assert.Equal(t, int64(0), cache.CountQueries(), "Expected initial count to be 0")
|
||||
|
||||
|
||||
// Add some entries
|
||||
cache.Set("key1", []byte("value1"), DefaultTestExpiration)
|
||||
cache.Set("key2", []byte("value2"), DefaultTestExpiration)
|
||||
cache.Set("key3", []byte("value3"), DefaultTestExpiration)
|
||||
|
||||
|
||||
// Check count
|
||||
assert.Equal(t, int64(3), cache.CountQueries(), "Expected count to be 3 after adding 3 entries")
|
||||
|
||||
|
||||
// Delete an entry
|
||||
cache.Delete("key1")
|
||||
|
||||
|
||||
// Check count after deletion
|
||||
assert.Equal(t, int64(2), cache.CountQueries(), "Expected count to be 2 after deleting 1 entry")
|
||||
}
|
||||
@@ -60,31 +60,31 @@ func TestMemoryCacheCountQueries(t *testing.T) {
|
||||
func TestMemoryCacheCleanExpiredEntries(t *testing.T) {
|
||||
// Create a cache with default expiration
|
||||
cache := New(10 * time.Second)
|
||||
|
||||
|
||||
// Add an entry that will expire quickly
|
||||
cache.Set("expire-soon", []byte("value1"), 10*time.Millisecond)
|
||||
|
||||
|
||||
// Add an entry that will not expire during the test
|
||||
cache.Set("expire-later", []byte("value3"), 10*time.Minute)
|
||||
|
||||
|
||||
// Initial count should be 2
|
||||
assert.Equal(t, int64(2), cache.CountQueries(), "Expected count to be 2 after adding entries")
|
||||
|
||||
|
||||
// Wait for short expiration
|
||||
time.Sleep(20 * time.Millisecond)
|
||||
|
||||
|
||||
// Get the expired key directly to verify it's expired
|
||||
_, expiredFound := cache.Get("expire-soon")
|
||||
assert.False(t, expiredFound, "Key 'expire-soon' should be expired now")
|
||||
|
||||
|
||||
// Verify the not-expired key is still there
|
||||
val, nonExpiredFound := cache.Get("expire-later")
|
||||
assert.True(t, nonExpiredFound, "Key 'expire-later' should not be expired")
|
||||
assert.Equal(t, []byte("value3"), val, "Expected correct value for 'expire-later'")
|
||||
|
||||
|
||||
// Manually clean expired entries
|
||||
cache.CleanExpiredEntries()
|
||||
|
||||
|
||||
// Count should be 1 now (only the non-expired entry)
|
||||
assert.Equal(t, int64(1), cache.CountQueries(), "Expected count to be 1 after cleaning expired entries")
|
||||
}
|
||||
}
|
||||
|
||||
Vendored
+1
-1
@@ -47,4 +47,4 @@ func TestRedisClear(t *testing.T) {
|
||||
assert.False(t, found, "Key2 should be deleted after Clear")
|
||||
_, found = redisConfig.Get("key3")
|
||||
assert.False(t, found, "Key3 should be deleted after Clear")
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user