Skip to content

Commit cdda46b

Browse files
pranavmishradatabrickspranavmishradatabricks
committed
updated test cases
1 parent ff6ef7b commit cdda46b

File tree

2 files changed

+140
-62
lines changed

2 files changed

+140
-62
lines changed

‎internal/cortex/frontend/transport/utils/utils.go‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ func NewFailedQueryCache(capacity int) (*FailedQueryCache, error) {
4141
}
4242

4343
// UpdateFailedQueryCache returns true if query is cached so that callsite can increase counter, returns message as a string for callsite to log outcome
44-
func updateFailedQueryCache(err error, queryExpressionNormalized string, queryExpressionRangeLength int, lruCache *lru.Cache) (bool, string) {
44+
func (f *FailedQueryCache) updateFailedQueryCache(err error, queryExpressionNormalized string, queryExpressionRangeLength int, lruCache *lru.Cache) (bool, string) {
4545
// Extracting error code from error string.
4646
codeExtract := f.errorExtract.FindStringSubmatch(err.Error())
4747

@@ -104,7 +104,7 @@ func updateFailedQueryCache(err error, queryExpressionNormalized string, queryEx
104104

105105
// QueryHitCache checks if the lru cache is hit and returns whether to increment counter for cache hits along with appropriate message.
106106
func queryHitCache(queryExpressionNormalized string, queryExpressionRangeLength int, lruCache *lru.Cache) (bool, string) {
107-
if value, ok := lruCache.Get(queryExpressionNormalized); ok && value.(int) >= queryExpressionRangeLength {
107+
if value, ok := lruCache.Get(queryExpressionNormalized); ok && value.(int) <= queryExpressionRangeLength {
108108
message := fmt.Sprintf(
109109
`%s: %s, %s: %s, %s: %d`, "msg", "Retrieved query from cache",
110110
"normalized query", queryExpressionNormalized,
@@ -139,19 +139,19 @@ func getQueryRangeSeconds(query url.Values) int {
139139
return end - start
140140
}
141141

142-
func normalizeQueryString(query url.Values) string {
142+
func (f *FailedQueryCache) normalizeQueryString(query url.Values) string {
143143
return f.regex.ReplaceAllString(query.Get("query"), " ")
144144
}
145145

146146
func (f *FailedQueryCache) CallUpdateFailedQueryCache(err error, query url.Values) (bool, string) {
147-
queryExpressionNormalized := normalizeQueryString(query)
147+
queryExpressionNormalized := f.normalizeQueryString(query)
148148
queryExpressionRangeLength := getQueryRangeSeconds(query)
149-
success, message := updateFailedQueryCache(err, queryExpressionNormalized, queryExpressionRangeLength, f.lruCache)
149+
success, message := f.updateFailedQueryCache(err, queryExpressionNormalized, queryExpressionRangeLength, f.lruCache)
150150
return success, message
151151
}
152152

153153
func (f *FailedQueryCache) CallQueryHitCache(query url.Values) (bool, string) {
154-
queryExpressionNormalized := normalizeQueryString(query)
154+
queryExpressionNormalized := f.normalizeQueryString(query)
155155
queryExpressionRangeLength := getQueryRangeSeconds(query)
156156
cached, message := queryHitCache(queryExpressionNormalized, queryExpressionRangeLength, f.lruCache)
157157
return cached, message

‎internal/cortex/frontend/transport/utils/utils_test.go‎

Lines changed: 134 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -6,65 +6,109 @@ package utils
66

77
import (
88
"errors"
9+
"net/url"
910
"testing"
1011
)
1112

1213
func TestNewFailedQueryCache(t *testing.T) {
13-
cache, msg := NewFailedQueryCache(2)
14+
cache, err := NewFailedQueryCache(2)
1415
if cache == nil {
1516
t.Fatalf("Expected cache to be created, but got nil")
1617
}
17-
if msg != "" {
18-
t.Fatalf("Expected no error message, but got: %s", msg)
18+
if err != nil {
19+
t.Fatalf("Expected no error message, but got: %s", err.Error())
1920
}
2021
}
2122

2223
func TestUpdateFailedQueryCache(t *testing.T) {
2324
cache, _ := NewFailedQueryCache(2)
24-
lruCache := cache.LruCache
2525

2626
tests := []struct {
27-
name string
28-
err error
29-
queryExpressionNormalized string
30-
queryExpressionRangeLength int
31-
expectedResult bool
32-
expectedMessageContains string
27+
name string
28+
err error
29+
query url.Values
30+
expectedResult bool
31+
expectedMessage string
3332
}{
3433
{
35-
name: "No error code in error message",
36-
err: errors.New("no error code here"),
37-
queryExpressionNormalized: "test_query",
38-
queryExpressionRangeLength: 60,
39-
expectedResult: false,
40-
expectedMessageContains: "msg: String regex conversion error, normalized query: test_query, query range seconds: 60, updating cache for error: no error code here",
34+
name: "No error code in error message",
35+
err: errors.New("no error code here"),
36+
query: url.Values{
37+
"start": {"100"},
38+
"end": {"200"},
39+
"query": {"test_query"},
40+
},
41+
expectedResult: false,
42+
expectedMessage: "msg: String regex conversion error, normalized query: test_query, query range seconds: 100, updating cache for error: no error code here",
4143
},
4244
{
43-
name: "Non-cacheable error code",
44-
err: errors.New("Code(500)"),
45-
queryExpressionNormalized: "test_query",
46-
queryExpressionRangeLength: 60,
47-
expectedResult: false,
48-
expectedMessageContains: "msg: Query not cached due to non-cacheable error code, normalized query: test_query, query range seconds: 60, updating cache for error: Code(500)",
45+
name: "Non-cacheable error code",
46+
err: errors.New("serads;ajkvsd( Code(500) code)asd"),
47+
query: url.Values{
48+
"start": {"100"},
49+
"end": {"200"},
50+
"query": {"test_query"},
51+
},
52+
expectedResult: false,
53+
expectedMessage: "msg: Query not cached due to non-cacheable error code, normalized query: test_query, query range seconds: 100, updating cache for error: serads;ajkvsd( Code(500) code)asd",
4954
},
5055
{
51-
name: "Cacheable error code",
52-
err: errors.New("Code(408)"),
53-
queryExpressionNormalized: "test_query",
54-
queryExpressionRangeLength: 60,
55-
expectedResult: true,
56-
expectedMessageContains: "msg: Cached a failed query, normalized query: test_query, range seconds: 60, updating cache for error: Code(408)",
56+
name: "Cacheable error code",
57+
err: errors.New("This is a random error Code(408). It is random."),
58+
query: url.Values{
59+
"start": {"100"},
60+
"end": {"200"},
61+
"query": {"test_query"},
62+
},
63+
expectedResult: true,
64+
expectedMessage: "msg: Cached a failed query, normalized query: test_query, range seconds: 100, updating cache for error: This is a random error Code(408). It is random.",
65+
},
66+
67+
{
68+
name: "Adding query with whitespace and ensuring it is normalized",
69+
err: errors.New("Adding error with query that has whitespace and tabs Code(408). Let's see what happens."),
70+
query: url.Values{
71+
"start": {"100"},
72+
"end": {"200"},
73+
"query": {"\n \t tes \t t query \n"},
74+
},
75+
expectedResult: true,
76+
expectedMessage: "msg: Cached a failed query, normalized query: tes t query , range seconds: 100, updating cache for error: Adding error with query that has whitespace and tabs Code(408). Let's see what happens.",
77+
},
78+
79+
{
80+
name: "Cacheable error code with range of 0, ensuring regex parsing is correct, and updating range length",
81+
err: errors.New("error code( Code(408) error.)"),
82+
query: url.Values{
83+
"start": {"100"},
84+
"end": {"180"},
85+
"query": {"test_query"},
86+
},
87+
expectedResult: true,
88+
expectedMessage: "msg: Cached a failed query, normalized query: test_query, range seconds: 80, updating cache for error: error code( Code(408) error.)",
89+
},
90+
91+
{
92+
name: "Successful update to range length",
93+
err: errors.New("error code( Code(408) error.)"),
94+
query: url.Values{
95+
"start": {"100"},
96+
"end": {"100"},
97+
"query": {"test_query"},
98+
},
99+
expectedResult: true,
100+
expectedMessage: "msg: Cached a failed query, normalized query: test_query, range seconds: 0, updating cache for error: error code( Code(408) error.)",
57101
},
58102
}
59103

60104
for _, tt := range tests {
61105
t.Run(tt.name, func(t *testing.T) {
62-
result, message := cache.UpdateFailedQueryCache(tt.err, tt.queryExpressionNormalized, tt.queryExpressionRangeLength, lruCache)
106+
result, message := cache.CallUpdateFailedQueryCache(tt.err, tt.query)
63107
if result != tt.expectedResult {
64108
t.Errorf("expected result %v, got %v", tt.expectedResult, result)
65109
}
66-
if !contains(message, tt.expectedMessageContains) {
67-
t.Errorf("expected message to contain %s, got %s", tt.expectedMessageContains, message)
110+
if message != tt.expectedMessage {
111+
t.Errorf("expected message to contain %s, got %s", tt.expectedMessage, message)
68112
}
69113
})
70114
}
@@ -73,47 +117,81 @@ func TestUpdateFailedQueryCache(t *testing.T) {
73117
// TestQueryHitCache tests the QueryHitCache method
74118
func TestQueryHitCache(t *testing.T) {
75119
cache, _ := NewFailedQueryCache(2)
76-
lruCache := cache.LruCache
120+
lruCache := cache.lruCache
77121

78-
lruCache.Add("test_query", 60)
122+
lruCache.Add("test_query", 100)
123+
lruCache.Add(" tes t query ", 100)
79124

80125
tests := []struct {
81-
name string
82-
queryExpressionNormalized string
83-
queryExpressionRangeLength int
84-
expectedResult bool
85-
expectedMessageContains string
126+
name string
127+
query url.Values
128+
expectedResult bool
129+
expectedMessage string
86130
}{
87131
{
88-
name: "Cache hit",
89-
queryExpressionNormalized: "test_query",
90-
queryExpressionRangeLength: 60,
91-
expectedResult: true,
92-
expectedMessageContains: "msg: Retrieved query from cache, normalized query: test_query, range seconds: 60",
132+
name: "Cache hit",
133+
query: url.Values{
134+
"start": {"100"},
135+
"end": {"200"},
136+
"query": {"test_query"},
137+
},
138+
expectedResult: true,
139+
expectedMessage: "msg: Retrieved query from cache, normalized query: test_query, range seconds: 100",
140+
},
141+
{
142+
name: "Cache miss",
143+
query: url.Values{
144+
"start": {"100"},
145+
"end": {"200"},
146+
"query": {"miss"},
147+
},
148+
expectedResult: false,
149+
expectedMessage: "",
150+
},
151+
152+
{
153+
name: "Cache miss due to shorter range length",
154+
query: url.Values{
155+
"start": {"100"},
156+
"end": {"150"},
157+
"query": {"test_query"},
158+
},
159+
expectedResult: false,
160+
expectedMessage: "",
161+
},
162+
163+
{
164+
name: "Cache hit whitespace",
165+
query: url.Values{
166+
"start": {"100"},
167+
"end": {"200"},
168+
"query": {" \n\ttes \tt \n query \t\n "},
169+
},
170+
expectedResult: true,
171+
expectedMessage: "msg: Retrieved query from cache, normalized query: tes t query , range seconds: 100",
93172
},
173+
94174
{
95-
name: "Cache miss",
96-
queryExpressionNormalized: "nonexistent_query",
97-
queryExpressionRangeLength: 60,
98-
expectedResult: false,
99-
expectedMessageContains: "",
175+
name: "Cache miss whitespace",
176+
query: url.Values{
177+
"start": {"100"},
178+
"end": {"200"},
179+
"query": {" \n\tte s \tt \n query \t\n "},
180+
},
181+
expectedResult: false,
182+
expectedMessage: "",
100183
},
101184
}
102185

103186
for _, tt := range tests {
104187
t.Run(tt.name, func(t *testing.T) {
105-
result, message := cache.QueryHitCache(tt.queryExpressionNormalized, tt.queryExpressionRangeLength, lruCache)
188+
result, message := cache.CallQueryHitCache(tt.query)
106189
if result != tt.expectedResult {
107190
t.Errorf("expected result %v, got %v", tt.expectedResult, result)
108191
}
109-
if !contains(message, tt.expectedMessageContains) {
110-
t.Errorf("expected message to contain %s, got %s", tt.expectedMessageContains, message)
192+
if message != tt.expectedMessage {
193+
t.Errorf("expected message to contain %s, got %s", tt.expectedMessage, message)
111194
}
112195
})
113196
}
114197
}
115-
116-
// contains checks if a string is contained within another string
117-
func contains(str, substr string) bool {
118-
return len(substr) == 0 || (len(str) >= len(substr) && str[len(str)-len(substr):] == substr)
119-
}

0 commit comments

Comments
 (0)