118 lines
3.4 KiB
Go
118 lines
3.4 KiB
Go
package meilisearch
|
|
|
|
import (
|
|
"net/url"
|
|
"reflect"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func (req *internalRequest) init() {
|
|
req.withQueryParams = make(map[string]string)
|
|
}
|
|
|
|
func formatDateForComparison(date time.Time) string {
|
|
const format = "2006-01-02T15:04:05Z"
|
|
return date.Format(format)
|
|
}
|
|
|
|
func TestConvertKeyToParsedKey(t *testing.T) {
|
|
key := Key{
|
|
Name: "test",
|
|
Description: "test description",
|
|
UID: "123",
|
|
Actions: []string{"read", "write"},
|
|
Indexes: []string{"index1", "index2"},
|
|
ExpiresAt: time.Now(),
|
|
}
|
|
|
|
expectedExpiresAt := formatDateForComparison(key.ExpiresAt)
|
|
parsedKey := convertKeyToParsedKey(key)
|
|
|
|
if parsedKey.Name != key.Name ||
|
|
parsedKey.Description != key.Description ||
|
|
parsedKey.UID != key.UID ||
|
|
!reflect.DeepEqual(parsedKey.Actions, key.Actions) ||
|
|
!reflect.DeepEqual(parsedKey.Indexes, key.Indexes) ||
|
|
parsedKey.ExpiresAt == nil || *parsedKey.ExpiresAt != expectedExpiresAt {
|
|
t.Errorf("convertKeyToParsedKey(%v) = %v; want %v", key, parsedKey, key)
|
|
}
|
|
}
|
|
|
|
func TestEncodeTasksQuery(t *testing.T) {
|
|
param := &TasksQuery{
|
|
Limit: 10,
|
|
From: 5,
|
|
Statuses: []TaskStatus{"queued", "running"},
|
|
Types: []TaskType{"type1", "type2"},
|
|
IndexUIDS: []string{"uid1", "uid2"},
|
|
UIDS: []int64{1, 2, 3},
|
|
CanceledBy: []int64{4, 5},
|
|
BeforeEnqueuedAt: time.Now().Add(-10 * time.Hour),
|
|
AfterEnqueuedAt: time.Now().Add(-20 * time.Hour),
|
|
BeforeStartedAt: time.Now().Add(-30 * time.Hour),
|
|
AfterStartedAt: time.Now().Add(-40 * time.Hour),
|
|
BeforeFinishedAt: time.Now().Add(-50 * time.Hour),
|
|
AfterFinishedAt: time.Now().Add(-60 * time.Hour),
|
|
}
|
|
req := &internalRequest{}
|
|
req.init()
|
|
|
|
encodeTasksQuery(param, req)
|
|
|
|
expectedParams := map[string]string{
|
|
"limit": strconv.FormatInt(param.Limit, 10),
|
|
"from": strconv.FormatInt(param.From, 10),
|
|
"statuses": "queued,running",
|
|
"types": "type1,type2",
|
|
"indexUids": "uid1,uid2",
|
|
"uids": "1,2,3",
|
|
"canceledBy": "4,5",
|
|
"beforeEnqueuedAt": formatDateForComparison(param.BeforeEnqueuedAt),
|
|
"afterEnqueuedAt": formatDateForComparison(param.AfterEnqueuedAt),
|
|
"beforeStartedAt": formatDateForComparison(param.BeforeStartedAt),
|
|
"afterStartedAt": formatDateForComparison(param.AfterStartedAt),
|
|
"beforeFinishedAt": formatDateForComparison(param.BeforeFinishedAt),
|
|
"afterFinishedAt": formatDateForComparison(param.AfterFinishedAt),
|
|
}
|
|
|
|
for k, v := range expectedParams {
|
|
if req.withQueryParams[k] != v {
|
|
t.Errorf("encodeTasksQuery() param %v = %v; want %v", k, req.withQueryParams[k], v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTransformStringVariadicToMap(t *testing.T) {
|
|
tests := []struct {
|
|
input []string
|
|
expect map[string]string
|
|
}{
|
|
{[]string{"primaryKey1"}, map[string]string{"primaryKey": "primaryKey1"}},
|
|
{nil, nil},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
result := transformStringVariadicToMap(test.input...)
|
|
if !reflect.DeepEqual(result, test.expect) {
|
|
t.Errorf("transformStringVariadicToMap(%v) = %v; want %v", test.input, result, test.expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestGenerateQueryForOptions(t *testing.T) {
|
|
options := map[string]string{
|
|
"key1": "value1",
|
|
"key2": "value2",
|
|
}
|
|
|
|
expected := url.Values{}
|
|
expected.Add("key1", "value1")
|
|
expected.Add("key2", "value2")
|
|
|
|
result := generateQueryForOptions(options)
|
|
if result != expected.Encode() {
|
|
t.Errorf("generateQueryForOptions(%v) = %v; want %v", options, result, expected.Encode())
|
|
}
|
|
}
|