Example #1
0
 def setUp(self):
     fixture.setup_database_settings()
     self._redis = Redis()
     self._mongo = Mongo("unittest")
     self._memcache = Memcache()
     self._redis.clear()
     self._mongo.clear()
     self._memcache.put("unittest:test", "X")
Example #2
0
class CountStoreTest(unittest.TestCase):
    
    def setUp(self):
        fixture.setup_database_settings()
        fixture.setup_mock_time()
        self._mongo = Mongo("CountStore")
        self._mongo.clear()

    def build_timeslice_docs(self, doc):
        timeslices = [
            fixture.jan_1st_2013_midday - 8*60*15,
            fixture.jan_1st_2013_midday - 7*60*15,
            fixture.jan_1st_2013_midday - 6*60*15,
            fixture.jan_1st_2013_midday - 5*60*15,
            fixture.jan_1st_2013_midday - 4*60*15,
            fixture.jan_1st_2013_midday - 3*60*15,
            fixture.jan_1st_2013_midday - 2*60*15,
            fixture.jan_1st_2013_midday - 60*15,
            fixture.jan_1st_2013_midday,
        ]

    def build_doc(orig_doc, timeslice):
        doc = copy(orig_doc)
        doc["timeslice"] = timeslice
        return doc
	return map(lambda ts: build_doc(doc, ts), timeslices)

    def delete_ids(self, docs):
        for doc in docs:
            del doc['_id']

    def get_all_docs(self):
        docs = list(self._mongo.find().sort('timeslice', 1))
        self.delete_ids(docs)
        return docs

    def test_put_no_total_count(self):
        countstore = CountStore()
        countstore.put("entity1", "test_entity", "test_seg")
        docs = self.get_all_docs()

        self.assertEqual(9, len(docs))

        expected = self.build_timeslice_docs({
            "entity_id"   : "entity1",
            "entity_type" : "test_entity",
            "segmentation": "test_seg",
            "count"       : 1,
        })
        self.assertEqual(expected, docs)

        fixture.setup_mock_time(fixture.jan_1st_2013_midday + 60*15)

        countstore.put("entity1", "test_entity", "test_seg")
        docs = self.get_all_docs()

        self.assertEqual(10, len(docs))

        expected = self.build_timeslice_docs({
            "entity_id"   : "entity1",
            "entity_type" : "test_entity",
            "segmentation": "test_seg",
            "count"       : 2,
        })

        expected[0]["count"] = 1
        last_doc = copy(expected[-1])
        last_doc["count"] = 1
        last_doc["timeslice"] = fixture.jan_1st_2013_midday + 60*15
        expected.append(last_doc)

        self.assertEqual(expected, docs)

    def test_put_with_total_count(self):
        countstore = CountStore()
        countstore.put("entity1", "test_entity", "test_seg", total_count = 10)
        docs = self.get_all_docs()

        self.assertEqual(9, len(docs))

        expected = self.build_timeslice_docs({
            "entity_id"   : "entity1",
            "entity_type" : "test_entity",
            "segmentation": "test_seg",
            "base_count"  : 10,
            "count"       : 1,
        })
        self.assertEqual(expected, docs)

        fixture.setup_mock_time(fixture.jan_1st_2013_midday + 60*15)

        countstore.put("entity1", "test_entity", "test_seg", total_count = 15)
        docs = self.get_all_docs()

        self.assertEqual(10, len(docs))

        expected = self.build_timeslice_docs({
            "entity_id"   : "entity1",
            "entity_type" : "test_entity",
            "segmentation": "test_seg",
            "count"       : 6,
	        "base_count"  : 10,
        })
        expected[0]["count"] = 1
        expected[0]["base_count"] = 10
        last_doc = copy(expected[-1])
        last_doc["count"] = 1
        last_doc["base_count"] = 15
        last_doc["timeslice"] = fixture.jan_1st_2013_midday + 60*15
        expected.append(last_doc)

        self.assertEqual(expected, docs)

    def test_get_top(self):
        countstore = CountStore()
        countstore.put("entity1", "test_entity", "test_seg")
        countstore.put("entity2", "test_entity", "test_seg")
        countstore.put("entity2", "test_entity", "test_seg")
        actual = countstore.get_top("test_entity", "test_seg", 10)
        expected = [("entity2", 2), ("entity1", 1)]

        self.assertEqual(expected, actual)

        fixture.setup_mock_time(fixture.jan_1st_2013_midday + 3600)

        countstore.put("entity1", "test_entity", "test_seg")
        countstore.put("entity1", "test_entity", "test_seg")
        countstore.put("entity3", "test_entity", "test_seg")
        actual = countstore.get_top("test_entity", "test_seg", 10)
        expected = [("entity1", 3), ("entity2", 2), ("entity3", 1)]

        self.assertEqual(expected, actual)

        fixture.setup_mock_time(fixture.jan_1st_2013_midday + 2*3600)

        countstore.put("entity3", "test_entity", "test_seg")
        countstore.put("entity3", "test_entity", "test_seg")
        actual = countstore.get_top("test_entity", "test_seg", 10)
        expected = [("entity3", 3), ("entity1", 2)]

        self.assertEqual(expected, actual)
Example #3
0
 def setUp(self):
     fixture.setup_database_settings()
     fixture.setup_mock_time()
     self._mongo = Mongo("CountStore")
     self._mongo.clear()
Example #4
0
class MongoStoreTest(unittest.TestCase):
    
    def setUp(self):
        fixture.setup_database_settings()
        self._redis = Redis()
        self._mongo = Mongo("unittest")
        self._memcache = Memcache()
        self._redis.clear()
        self._mongo.clear()
        self._memcache.put("unittest:test", "X")

    def test_no_cache(self):
        store = MongoStore("unittest")
        actual = store.save({"_id": "test", "hello": "world"})
        expected = "test"
        self.assertEqual(expected, actual)
        
        actual = store.find_one("test")
        expected = {"_id": "test", "hello": "world"}
        self.assertEqual(expected, actual)
        
        store.save({"_id": "test2", "goodbye": "world"})
        
        actual = list(store.find({}))
        expected = [
            {"_id": "test", "hello": "world"},
            {"_id": "test2", "goodbye": "world"}
        ]
        self.assertEqual(expected, actual)

        actual = list(store.find({"goodbye": {"$exists": True}}))
        expected = [{"_id": "test2", "goodbye": "world"}]
        self.assertEqual(expected, actual)
        
        actual = list(store.find().limit(1))
        expected = [{"_id": "test", "hello": "world"}]
        self.assertEqual(expected, actual)
        
        actual = store.count()
        self.assertEqual(2, actual)
        
        store.delete_one("test")
        actual = list(store.find())
        expected = [{"_id": "test2", "goodbye": "world"}]
        
        store.update({"_id": "test2"}, {"$set":{"goodbye": "universe"}})
        actual = store.find_one("test2")
        expected = {"_id": "test2", "goodbye": "universe"}
        self.assertEqual(expected, actual)
        
        store.update({"_id": "test3"}, {"$set":{"goodbye": "multiverse"}}, upsert=True)
        actual = store.find_one("test3")
        expected = {"_id": "test3", "goodbye": "multiverse"}
        self.assertEqual(expected, actual)
        
    def test_redis_cache(self):
        settings.MongoStores["unittest"]["cachetype"] = CacheType.Persistent
        store = MongoStore("unittest")
        
        store.save({"_id": "test", "hello": "world"})
        actual = self._mongo.find_one("test")
        self.assertEqual({"_id": "test", "hello": "world"}, actual)
        
        actual = self._redis.get("unittest:test")
        expected = serialize({"_id": "test", "hello": "world"})
        self.assertEqual(expected, actual)
        
        self._mongo.delete_one("test")
        actual = self._mongo.find_one("test")
        self.assertEqual(None, actual)
        
        actual = store.find_one("test")
        self.assertEqual({"_id": "test", "hello": "world"}, actual)
        
        store.save({"_id": "test", "hello": "world"})
        store.update({"_id": "test"}, {"$set":{"hello": "universe"}})
        actual = self._redis.get("unittest:test")
        expected = serialize({"_id": "test", "hello": "universe"})
        self.assertEqual(expected, actual)
        
        store.delete_one("test")
        actual = store.find_one("test")
        self.assertEqual(None, actual)
        actual = self._redis.get("unittest:test")
        self.assertEqual(None, actual)
        
    def test_memcache_cache(self):
        settings.MongoStores["unittest"]["cachetype"] = CacheType.Volatile
        store = MongoStore("unittest")
        
        actual = self._memcache.get("unittest:test")
        self.assertEqual("X", actual)
        
        store.save({"_id": "test", "hello": "world"})
        actual = self._mongo.find_one("test")
        self.assertEqual({"_id": "test", "hello": "world"}, actual)
        
        actual = self._memcache.get("unittest:test")
        expected = serialize({"_id": "test", "hello": "world"})
        self.assertEqual(expected, actual)
        
        self._mongo.delete_one("test")
        actual = self._mongo.find_one("test")
        self.assertEqual(None, actual)
        
        actual = store.find_one("test")
        self.assertEqual({"_id": "test", "hello": "world"}, actual)
        
        store.save({"_id": "test", "hello": "world"})
        store.update({"_id": "test"}, {"$set":{"hello": "universe"}})
        actual = self._memcache.get("unittest:test")
        expected = serialize({"_id": "test", "hello": "universe"})
        self.assertEqual(expected, actual)
        
        store.delete_one("test")
        actual = store.find_one("test")
        self.assertEqual(None, actual)
        actual = self._memcache.get("unittest:test")
        self.assertEqual("X", actual)