gorm-cache/memory_adapter_test.go at main · restayway/gorm-cache · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
package gormcache

import (
	"context"
	"testing"
	"time"
)

func TestMemoryAdapterSetGet(t *testing.T) {
	adapter := NewMemoryAdapter()
	defer adapter.Close()

	ctx := context.Background()
	key := "test:key"
	value := []byte("test value")

	// Set value
	err := adapter.Set(ctx, key, value, 1*time.Minute)
	if err != nil {
		t.Fatalf("failed to set: %v", err)
	}

	// Get value
	result, err := adapter.Get(ctx, key)
	if err != nil {
		t.Fatalf("failed to get: %v", err)
	}

	if string(result) != string(value) {
		t.Errorf("expected '%s', got '%s'", value, result)
	}
}

func TestMemoryAdapterDelete(t *testing.T) {
	adapter := NewMemoryAdapter()
	defer adapter.Close()

	ctx := context.Background()
	key := "test:key"
	value := []byte("test value")

	// Set value
	adapter.Set(ctx, key, value, 1*time.Minute)

	// Delete value
	err := adapter.Delete(ctx, key)
	if err != nil {
		t.Fatalf("failed to delete: %v", err)
	}

	// Try to get deleted value
	_, err = adapter.Get(ctx, key)
	if err == nil {
		t.Error("expected error, got nil")
	}
}

func TestMemoryAdapterDeletePattern(t *testing.T) {
	adapter := NewMemoryAdapter()
	defer adapter.Close()

	ctx := context.Background()

	// Set multiple values
	adapter.Set(ctx, "user:1", []byte("value1"), 1*time.Minute)
	adapter.Set(ctx, "user:2", []byte("value2"), 1*time.Minute)
	adapter.Set(ctx, "order:1", []byte("value3"), 1*time.Minute)

	// Delete pattern
	err := adapter.DeletePattern(ctx, "user:*")
	if err != nil {
		t.Fatalf("failed to delete pattern: %v", err)
	}

	// Check user keys are deleted
	_, err = adapter.Get(ctx, "user:1")
	if err == nil {
		t.Error("expected user:1 to be deleted")
	}

	_, err = adapter.Get(ctx, "user:2")
	if err == nil {
		t.Error("expected user:2 to be deleted")
	}

	// Check order key still exists
	_, err = adapter.Get(ctx, "order:1")
	if err != nil {
		t.Error("expected order:1 to exist")
	}
}

func TestMemoryAdapterClear(t *testing.T) {
	adapter := NewMemoryAdapter()
	defer adapter.Close()

	ctx := context.Background()

	// Set multiple values
	adapter.Set(ctx, "key1", []byte("value1"), 1*time.Minute)
	adapter.Set(ctx, "key2", []byte("value2"), 1*time.Minute)

	// Clear all
	err := adapter.Clear(ctx)
	if err != nil {
		t.Fatalf("failed to clear: %v", err)
	}

	// Check all keys are deleted
	_, err = adapter.Get(ctx, "key1")
	if err == nil {
		t.Error("expected key1 to be deleted")
	}

	_, err = adapter.Get(ctx, "key2")
	if err == nil {
		t.Error("expected key2 to be deleted")
	}
}

func TestMemoryAdapterExpiration(t *testing.T) {
	adapter := NewMemoryAdapter()
	defer adapter.Close()

	ctx := context.Background()
	key := "test:key"
	value := []byte("test value")

	// Set value with short TTL
	adapter.Set(ctx, key, value, 100*time.Millisecond)

	// Get value immediately
	_, err := adapter.Get(ctx, key)
	if err != nil {
		t.Fatalf("failed to get: %v", err)
	}

	// Wait for expiration
	time.Sleep(150 * time.Millisecond)

	// Try to get expired value
	_, err = adapter.Get(ctx, key)
	if err == nil {
		t.Error("expected error for expired key, got nil")
	}
}