1import { toFilters, toUrl } from './urlParser';
2import { AdHocVariableFilter } from 'app/features/variables/types';
3import { UrlQueryValue } from '@grafana/data';
4
5describe('urlParser', () => {
6  describe('parsing toUrl with no filters', () => {
7    it('then url params should be correct', () => {
8      const filters: AdHocVariableFilter[] = [];
9      const expected: string[] = [];
10
11      expect(toUrl(filters)).toEqual(expected);
12    });
13  });
14
15  describe('parsing toUrl with filters', () => {
16    it('then url params should be correct', () => {
17      const a = createFilter('a');
18      const b = createFilter('b', '>');
19
20      const filters: AdHocVariableFilter[] = [a, b];
21
22      const expectedA = `${a.key}|${a.operator}|${a.value}`;
23      const expectedB = `${b.key}|${b.operator}|${b.value}`;
24      const expected: string[] = [expectedA, expectedB];
25
26      expect(toUrl(filters)).toEqual(expected);
27    });
28  });
29
30  describe('parsing toUrl with filters containing special chars', () => {
31    it('then url params should be correct', () => {
32      const a = createFilter('a|');
33      const b = createFilter('b', '>');
34
35      const filters: AdHocVariableFilter[] = [a, b];
36
37      const expectedA = `a__gfp__-key|${a.operator}|a__gfp__-value`;
38      const expectedB = `${b.key}|${b.operator}|${b.value}`;
39      const expected: string[] = [expectedA, expectedB];
40
41      expect(toUrl(filters)).toEqual(expected);
42    });
43  });
44
45  describe('parsing toUrl with filters without values', () => {
46    it('then url params should be correct', () => {
47      const a: AdHocVariableFilter = {
48        value: '',
49        key: 'key',
50        operator: '',
51        condition: '',
52      };
53
54      const filters: AdHocVariableFilter[] = [a];
55
56      const expectedA = `key||`;
57      const expected: string[] = [expectedA];
58
59      expect(toUrl(filters)).toEqual(expected);
60    });
61  });
62
63  describe('parsing toUrl with filters with undefined values', () => {
64    it('then url params should be correct', () => {
65      const a = ({
66        value: undefined,
67        key: 'key',
68        operator: undefined,
69        condition: '',
70      } as unknown) as AdHocVariableFilter;
71
72      const filters: AdHocVariableFilter[] = [a];
73
74      const expectedA = `key||`;
75      const expected: string[] = [expectedA];
76
77      expect(toUrl(filters)).toEqual(expected);
78    });
79  });
80
81  describe('parsing toUrl with filters with number values', () => {
82    it('then url params should be correct', () => {
83      const a = ({
84        value: 1974,
85        key: 'key',
86        operator: '=',
87        condition: '',
88      } as unknown) as AdHocVariableFilter;
89
90      const filters: AdHocVariableFilter[] = [a];
91
92      const expectedA = `key|=|1974`;
93      const expected: string[] = [expectedA];
94
95      expect(toUrl(filters)).toEqual(expected);
96    });
97  });
98
99  describe('parsing toUrl with filters with boolean values', () => {
100    it('then url params should be correct', () => {
101      const a = ({
102        value: false,
103        key: 'key',
104        operator: '=',
105        condition: '',
106      } as unknown) as AdHocVariableFilter;
107
108      const filters: AdHocVariableFilter[] = [a];
109
110      const expectedA = `key|=|false`;
111      const expected: string[] = [expectedA];
112
113      expect(toUrl(filters)).toEqual(expected);
114    });
115  });
116
117  describe('parsing toFilters with url containing no filters as string', () => {
118    it('then url params should be correct', () => {
119      const url: UrlQueryValue = '';
120      const expected: AdHocVariableFilter[] = [];
121      expect(toFilters(url)).toEqual(expected);
122    });
123  });
124
125  describe('parsing toFilters with url containing no filters as []', () => {
126    it('then url params should be correct', () => {
127      const url: UrlQueryValue = [];
128      const expected: AdHocVariableFilter[] = [];
129      expect(toFilters(url)).toEqual(expected);
130    });
131  });
132
133  describe('parsing toFilters with url containing one filter as string', () => {
134    it('then url params should be correct', () => {
135      const url: UrlQueryValue = 'a-key|=|a-value';
136      const a = createFilter('a', '=');
137      const expected: AdHocVariableFilter[] = [a];
138
139      expect(toFilters(url)).toEqual(expected);
140    });
141  });
142
143  describe('parsing toFilters with url containing filters', () => {
144    it('then url params should be correct', () => {
145      const url: UrlQueryValue = ['a-key|=|a-value', 'b-key|>|b-value'];
146      const a = createFilter('a', '=');
147      const b = createFilter('b', '>');
148      const expected: AdHocVariableFilter[] = [a, b];
149
150      expect(toFilters(url)).toEqual(expected);
151    });
152  });
153
154  describe('parsing toFilters with url containing special chars', () => {
155    it('then url params should be correct', () => {
156      const url: UrlQueryValue = ['a__gfp__-key|=|a__gfp__-value', 'b-key|>|b-value'];
157      const a = createFilter('a|', '=');
158      const b = createFilter('b', '>');
159      const expected: AdHocVariableFilter[] = [a, b];
160
161      expect(toFilters(url)).toEqual(expected);
162    });
163  });
164
165  describe('parsing toFilters with url containing filter with empty values', () => {
166    it('then url params should be correct', () => {
167      const url: UrlQueryValue = 'key||';
168      const expected: AdHocVariableFilter[] = [
169        {
170          value: '',
171          key: 'key',
172          operator: '',
173          condition: '',
174        },
175      ];
176
177      expect(toFilters(url)).toEqual(expected);
178    });
179  });
180
181  describe('parsing toFilters with url containing no filters as string', () => {
182    it('then url params should be correct', () => {
183      const url: UrlQueryValue = '';
184      const expected: AdHocVariableFilter[] = [];
185      expect(toFilters(url)).toEqual(expected);
186    });
187  });
188});
189
190function createFilter(value: string, operator = '='): AdHocVariableFilter {
191  return {
192    value: `${value}-value`,
193    key: `${value}-key`,
194    operator: operator,
195    condition: '',
196  };
197}
198