1"""
2    :codeauthor: Jayesh Kariya <jayeshk@saltstack.com>
3"""
4
5from datetime import datetime
6
7import salt.modules.redismod as redismod
8from tests.support.mixins import LoaderModuleMockMixin
9from tests.support.mock import MagicMock
10from tests.support.unit import TestCase
11
12
13class Mockredis:
14    """
15    Mock redis class
16    """
17
18    class ConnectionError(Exception):
19        """
20        Mock ConnectionError class
21        """
22
23
24class MockConnect:
25    """
26    Mock Connect class
27    """
28
29    counter = 0
30
31    def __init__(self):
32        self.name = None
33        self.pattern = None
34        self.value = None
35        self.key = None
36        self.seconds = None
37        self.timestamp = None
38        self.field = None
39        self.start = None
40        self.stop = None
41        self.master_host = None
42        self.master_port = None
43
44    @staticmethod
45    def bgrewriteaof():
46        """
47        Mock bgrewriteaof method
48        """
49        return "A"
50
51    @staticmethod
52    def bgsave():
53        """
54        Mock bgsave method
55        """
56        return "A"
57
58    def config_get(self, pattern):
59        """
60        Mock config_get method
61        """
62        self.pattern = pattern
63        return "A"
64
65    def config_set(self, name, value):
66        """
67        Mock config_set method
68        """
69        self.name = name
70        self.value = value
71        return "A"
72
73    @staticmethod
74    def dbsize():
75        """
76        Mock dbsize method
77        """
78        return "A"
79
80    @staticmethod
81    def delete():
82        """
83        Mock delete method
84        """
85        return "A"
86
87    def exists(self, key):
88        """
89        Mock exists method
90        """
91        self.key = key
92        return "A"
93
94    def expire(self, key, seconds):
95        """
96        Mock expire method
97        """
98        self.key = key
99        self.seconds = seconds
100        return "A"
101
102    def expireat(self, key, timestamp):
103        """
104        Mock expireat method
105        """
106        self.key = key
107        self.timestamp = timestamp
108        return "A"
109
110    @staticmethod
111    def flushall():
112        """
113        Mock flushall method
114        """
115        return "A"
116
117    @staticmethod
118    def flushdb():
119        """
120        Mock flushdb method
121        """
122        return "A"
123
124    def get(self, key):
125        """
126        Mock get method
127        """
128        self.key = key
129        return "A"
130
131    def hget(self, key, field):
132        """
133        Mock hget method
134        """
135        self.key = key
136        self.field = field
137        return "A"
138
139    def hgetall(self, key):
140        """
141        Mock hgetall method
142        """
143        self.key = key
144        return "A"
145
146    @staticmethod
147    def info():
148        """
149        Mock info method
150        """
151        return "A"
152
153    def keys(self, pattern):
154        """
155        Mock keys method
156        """
157        self.pattern = pattern
158        return "A"
159
160    def type(self, key):
161        """
162        Mock type method
163        """
164        self.key = key
165        return "A"
166
167    @staticmethod
168    def lastsave():
169        """
170        Mock lastsave method
171        """
172        return datetime.now()
173
174    def llen(self, key):
175        """
176        Mock llen method
177        """
178        self.key = key
179        return "A"
180
181    def lrange(self, key, start, stop):
182        """
183        Mock lrange method
184        """
185        self.key = key
186        self.start = start
187        self.stop = stop
188        return "A"
189
190    @staticmethod
191    def ping():
192        """
193        Mock ping method
194        """
195        MockConnect.counter = MockConnect.counter + 1
196        if MockConnect.counter == 1:
197            return "A"
198        elif MockConnect.counter in (2, 3, 5):
199            raise Mockredis.ConnectionError("foo")
200
201    @staticmethod
202    def save():
203        """
204        Mock save method
205        """
206        return "A"
207
208    def set(self, key, value):
209        """
210        Mock set method
211        """
212        self.key = key
213        self.value = value
214        return "A"
215
216    @staticmethod
217    def shutdown():
218        """
219        Mock shutdown method
220        """
221        return "A"
222
223    def slaveof(self, master_host, master_port):
224        """
225        Mock slaveof method
226        """
227        self.master_host = master_host
228        self.master_port = master_port
229        return "A"
230
231    def smembers(self, key):
232        """
233        Mock smembers method
234        """
235        self.key = key
236        return "A"
237
238    @staticmethod
239    def time():
240        """
241        Mock time method
242        """
243        return "A"
244
245    def zcard(self, key):
246        """
247        Mock zcard method
248        """
249        self.key = key
250        return "A"
251
252    def zrange(self, key, start, stop):
253        """
254        Mock zrange method
255        """
256        self.key = key
257        self.start = start
258        self.stop = stop
259        return "A"
260
261
262class RedismodTestCase(TestCase, LoaderModuleMockMixin):
263    """
264    Test cases for salt.modules.redismod
265    """
266
267    def setup_loader_modules(self):
268        return {
269            redismod: {
270                "redis": Mockredis,
271                "_connect": MagicMock(return_value=MockConnect()),
272            }
273        }
274
275    def test_bgrewriteaof(self):
276        """
277        Test to asynchronously rewrite the append-only file
278        """
279        self.assertEqual(redismod.bgrewriteaof(), "A")
280
281    def test_bgsave(self):
282        """
283        Test to asynchronously save the dataset to disk
284        """
285        self.assertEqual(redismod.bgsave(), "A")
286
287    def test_config_get(self):
288        """
289        Test to get redis server configuration values
290        """
291        self.assertEqual(redismod.config_get("*"), "A")
292
293    def test_config_set(self):
294        """
295        Test to set redis server configuration values
296        """
297        self.assertEqual(redismod.config_set("name", "value"), "A")
298
299    def test_dbsize(self):
300        """
301        Test to return the number of keys in the selected database
302        """
303        self.assertEqual(redismod.dbsize(), "A")
304
305    def test_delete(self):
306        """
307        Test to deletes the keys from redis, returns number of keys deleted
308        """
309        self.assertEqual(redismod.delete(), "A")
310
311    def test_exists(self):
312        """
313        Test to return true if the key exists in redis
314        """
315        self.assertEqual(redismod.exists("key"), "A")
316
317    def test_expire(self):
318        """
319        Test to set a keys time to live in seconds
320        """
321        self.assertEqual(redismod.expire("key", "seconds"), "A")
322
323    def test_expireat(self):
324        """
325        Test to set a keys expire at given UNIX time
326        """
327        self.assertEqual(redismod.expireat("key", "timestamp"), "A")
328
329    def test_flushall(self):
330        """
331        Test to remove all keys from all databases
332        """
333        self.assertEqual(redismod.flushall(), "A")
334
335    def test_flushdb(self):
336        """
337        Test to remove all keys from the selected database
338        """
339        self.assertEqual(redismod.flushdb(), "A")
340
341    def test_get_key(self):
342        """
343        Test to get redis key value
344        """
345        self.assertEqual(redismod.get_key("key"), "A")
346
347    def test_hget(self):
348        """
349        Test to get specific field value from a redis hash, returns dict
350        """
351        self.assertEqual(redismod.hget("key", "field"), "A")
352
353    def test_hgetall(self):
354        """
355        Test to get all fields and values from a redis hash, returns dict
356        """
357        self.assertEqual(redismod.hgetall("key"), "A")
358
359    def test_info(self):
360        """
361        Test to get information and statistics about the server
362        """
363        self.assertEqual(redismod.info(), "A")
364
365    def test_keys(self):
366        """
367        Test to get redis keys, supports glob style patterns
368        """
369        self.assertEqual(redismod.keys("pattern"), "A")
370
371    def test_key_type(self):
372        """
373        Test to get redis key type
374        """
375        self.assertEqual(redismod.key_type("key"), "A")
376
377    def test_lastsave(self):
378        """
379        Test to get the UNIX time in seconds of the last successful
380        save to disk
381        """
382        self.assertTrue(redismod.lastsave())
383
384    def test_llen(self):
385        """
386        Test to get the length of a list in Redis
387        """
388        self.assertEqual(redismod.llen("key"), "A")
389
390    def test_lrange(self):
391        """
392        Test to get a range of values from a list in Redis
393        """
394        self.assertEqual(redismod.lrange("key", "start", "stop"), "A")
395
396    def test_ping(self):
397        """
398        Test to ping the server, returns False on connection errors
399        """
400        self.assertEqual(redismod.ping(), "A")
401
402        self.assertFalse(redismod.ping())
403
404    def test_save(self):
405        """
406        Test to synchronously save the dataset to disk
407        """
408        self.assertEqual(redismod.save(), "A")
409
410    def test_set_key(self):
411        """
412        Test to set redis key value
413        """
414        self.assertEqual(redismod.set_key("key", "value"), "A")
415
416    def test_shutdown(self):
417        """
418        Test to synchronously save the dataset to disk and then
419        shut down the server
420        """
421        self.assertFalse(redismod.shutdown())
422
423        self.assertTrue(redismod.shutdown())
424
425        self.assertFalse(redismod.shutdown())
426
427    def test_slaveof(self):
428        """
429        Test to make the server a slave of another instance, or
430        promote it as master
431        """
432        self.assertEqual(redismod.slaveof("master_host", "master_port"), "A")
433
434    def test_smembers(self):
435        """
436        Test to get members in a Redis set
437        """
438        self.assertListEqual(redismod.smembers("key"), ["A"])
439
440    def test_time(self):
441        """
442        Test to return the current server UNIX time in seconds
443        """
444        self.assertEqual(redismod.time(), "A")
445
446    def test_zcard(self):
447        """
448        Test to get the length of a sorted set in Redis
449        """
450        self.assertEqual(redismod.zcard("key"), "A")
451
452    def test_zrange(self):
453        """
454        Test to get a range of values from a sorted set in Redis by index
455        """
456        self.assertEqual(redismod.zrange("key", "start", "stop"), "A")
457