Merge pull request #94 from splitio/bug/ReadOnlyCluster

[SDKS-120]: Read Only Cluster

Author: mmelograno

.gitignore

@@ -23,6 +23,7 @@ var/
 *.egg-info/
 .installed.cfg
 *.egg
+.vscode
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

splitio/brokers.py

@@ -513,8 +513,7 @@ def __init__(self, redis):
         split_fetcher = CacheBasedSplitFetcher(split_cache)
 
         impressions_cache = RedisImpressionsCache(redis)
-        delegate_treatment_log = CacheBasedTreatmentLog(impressions_cache)
-        treatment_log = AsyncTreatmentLog(delegate_treatment_log)
+        treatment_log = CacheBasedTreatmentLog(impressions_cache)
 
         metrics_cache = RedisMetricsCache(redis)
         delegate_metrics = CacheBasedMetrics(metrics_cache)

splitio/redis_support.py

@@ -71,21 +71,25 @@ def register_segment(self, segment_name):
         :param segment_name: Name of the segment.
         :type segment_name: str
         '''
-        self._redis.sadd(
-            RedisSegmentCache._KEY_TEMPLATE.format(suffix='registered'),
-            segment_name
-        )
+        # self._redis.sadd(
+        #     RedisSegmentCache._KEY_TEMPLATE.format(suffix='registered'),
+        #     segment_name
+        # )
+        # @TODO The Segment logic for redis should be removed.
+        pass
 
     def unregister_segment(self, segment_name):
         '''
         Unregister a segment from the automatic update process.
         :param segment_name: Name of the segment.
         :type segment_name: str
         '''
-        self._redis.srem(
-            RedisSegmentCache._KEY_TEMPLATE.format(suffix='registered'),
-            segment_name
-        )
+        # self._redis.srem(
+        #     RedisSegmentCache._KEY_TEMPLATE.format(suffix='registered'),
+        #     segment_name
+        # )
+        # @TODO The Segment logic for redis should be removed.
+        pass
 
     def get_registered_segments(self):
         '''

splitio/tests/splitChangesReadOnly.json

@@ -0,0 +1,46 @@
+{
+    "splits": [
+        {
+            "orgId": null,
+            "environment": null,
+            "trafficTypeId": null,
+            "trafficTypeName": null,
+            "name": "test_read_only_1",
+            "seed": -1329591480,
+            "status": "ACTIVE",
+            "killed": false,
+            "defaultTreatment": "off",
+            "changeNumber": 1325599980,
+            "conditions": [
+                {
+                    "matcherGroup": {
+                        "combiner": "AND",
+                        "matchers": [
+                            {
+                                "keySelector": null,
+                                "matcherType": "WHITELIST",
+                                "negate": false,
+                                "userDefinedSegmentMatcherData": null,
+                                "whitelistMatcherData": {
+                                    "whitelist": [
+                                    "valid"
+                                    ]
+                                },
+                                "unaryNumericMatcherData": null,
+                                "betweenMatcherData": null
+                            }
+                        ]
+                    },
+                    "partitions": [
+                        {
+                            "treatment": "on",
+                            "size": 100
+                        }
+                    ]
+                }
+            ]
+        }
+    ],
+    "since": -1,
+    "till": 1461957424937
+  }

splitio/tests/test_clients.py

@@ -1165,6 +1165,7 @@ def setUp(self):
             'splitio.tests.test_clients.LocalhostBroker._build_split_fetcher')
 
         self.open_mock = self.patch_builtin('open')
+        self.threading_mock = self.patch('threading.Thread')
         self.broker = LocalhostBroker()
 
     def test_skips_comment_lines(self):

splitio/tests/test_redis_cache.py

@@ -8,9 +8,14 @@
 
 from os.path import dirname, join
 from unittest import TestCase
+from splitio.tests.utils import MockUtilsMixin
 from json import load
 
 from splitio.redis_support import (RedisSplitCache, RedisSegmentCache, get_redis)
+from redis import StrictRedis
+from splitio.clients import Client
+from splitio.prefix_decorator import PrefixDecorator
+from splitio.brokers import RedisBroker
 
 class CacheInterfacesTests(TestCase):
     def setUp(self):
@@ -42,20 +47,58 @@ def test_split_cache_interface(self):
         self._redis_split_cache.set_change_number(1212)
         self.assertEqual(1212, self._redis_split_cache.get_change_number())
 
+    # @TODO This tests should be removed regarding that this is not supported by redis now.
+    # def testSegmentCacheInterface(self):
+    #     with open(self._segment_changes_file_name) as f:
+    #         self._json = load(f)
+    #         segment_name = self._json['name']
+    #         segment_change_number = self._json['till']
+    #         segment_keys = self._json['added']
 
+    #     self._redis_segment_cache.set_change_number(segment_name, segment_change_number)
+    #     self.assertEqual(segment_change_number, self._redis_segment_cache.get_change_number(segment_name))
 
-    def testSegmentCacheInterface(self):
-        with open(self._segment_changes_file_name) as f:
+    #     self._redis_segment_cache.add_keys_to_segment(segment_name, segment_keys)
+    #     self.assertTrue(self._redis_segment_cache.is_in_segment(segment_name, segment_keys[0]))
+
+    #     self._redis_segment_cache.remove_keys_from_segment(segment_name, [segment_keys[0]])
+    #     self.assertFalse(self._redis_segment_cache.is_in_segment(segment_name, segment_keys[0]))
+
+class ReadOnlyRedisMock(PrefixDecorator):
+
+    def __init__(self, *args, **kwargs):
+        """
+        Bases on PrefixDecorator.
+        """
+        PrefixDecorator.__init__(self, *args, **kwargs)
+
+    def sadd(self, name, *values):
+        """
+        Decorated sadd to simulate read only exception error.
+        """
+        raise Exception('ReadOnlyError')
+
+class RedisReadOnlyTest(TestCase, MockUtilsMixin):
+    def setUp(self):
+        self._split_changes_file_name = join(dirname(__file__), 'splitChangesReadOnly.json')
+        
+        with open(self._split_changes_file_name) as f:
             self._json = load(f)
-            segment_name = self._json['name']
-            segment_change_number = self._json['till']
-            segment_keys = self._json['added']
+            split_definition = self._json['splits'][0]
+            split_name = split_definition['name']
+
+        self._redis = get_redis({'redisPrefix': 'test'})
 
-        self._redis_segment_cache.set_change_number(segment_name, segment_change_number)
-        self.assertEqual(segment_change_number, self._redis_segment_cache.get_change_number(segment_name))
+        self._mocked_redis = ReadOnlyRedisMock(self._redis)
+        self._redis_split_cache = RedisSplitCache(self._redis)
+        self._redis_split_cache.add_split(split_name, split_definition)
+        self._client = Client(RedisBroker(self._mocked_redis))
 
-        self._redis_segment_cache.add_keys_to_segment(segment_name, segment_keys)
-        self.assertTrue(self._redis_segment_cache.is_in_segment(segment_name, segment_keys[0]))
+        self._impression = mock.MagicMock()
+        self._start = mock.MagicMock()
+        self._operation = mock.MagicMock()
 
-        self._redis_segment_cache.remove_keys_from_segment(segment_name, [segment_keys[0]])
-        self.assertFalse(self._redis_segment_cache.is_in_segment(segment_name, segment_keys[0]))
+    def test_redis_read_only_mode(self):
+        self.assertEqual(self._client.get_treatment('valid', 'test_read_only_1'), 'on')
+        self.assertEqual(self._client.get_treatment('invalid', 'test_read_only_1'), 'off')
+        self.assertEqual(self._client.get_treatment('valid', 'test_read_only_1_invalid'), 'control')

splitio/tests/test_redis_support.py

@@ -32,18 +32,6 @@ def setUp(self):
         self.some_redis = mock.MagicMock()
         self.a_segment_cache = RedisSegmentCache(self.some_redis)
 
-    def test_unregister_segment_removes_segment_name_to_register_segments_set(self):
-        """Test that unregister_segment removes segment name to registered segments set"""
-        self.a_segment_cache.unregister_segment(self.some_segment_name)
-        self.some_redis.srem.assert_called_once_with('SPLITIO.segments.registered',
-                                                     self.some_segment_name)
-
-    def test_get_registered_segments_returns_registered_segments_set_members(self):
-        """Test that get_registered_segments returns the registered segments sets members"""
-        self.assertEqual(self.some_redis.smembers.return_value,
-                         self.a_segment_cache.get_registered_segments())
-        self.some_redis.smembers.assert_called_once_with('SPLITIO.segments.registered')
-
     def test_add_keys_to_segment_adds_keys_to_segment_set(self):
         """Test that add_keys_to_segment adds the keys to the segment key set"""
         self.a_segment_cache.add_keys_to_segment(self.some_segment_name_str, self.some_segment_keys)
@@ -88,7 +76,7 @@ def test_get_change_number_returns_default_value_if_not_set(self):
         self.assertEqual(-1,
                          self.a_segment_cache.get_change_number(self.some_segment_name_str))
 
-
+                         
 class RedisSplitCacheTests(TestCase, MockUtilsMixin):
     def setUp(self):
         self.decode_mock = self.patch('splitio.redis_support.decode')