Exemple #1
0
 def setUp(self):
     self._drop_db()
     self.original = MongoDict("original",
                               mongo_host=MONGO_HOST,
                               mongo_port=MONGO_PORT)
     self.original2 = MongoDict("original",
                                mongo_host=MONGO_HOST,
                                mongo_port=MONGO_PORT)
     self.fork1 = self.original.fork("fork1")
Exemple #2
0
 def setUp(self):
     self._drop()
     self.original = MongoDict("original",
                               mongo_host=MONGO_HOST,
                               mongo_port=MONGO_PORT)
     self.original["val1"] = 55
     self.original["val2"] = "hello"
     self.fork = self.original.fork("fork")
     del self.fork["val1"]
     del self.fork["val2"]
Exemple #3
0
 def setUp(self):
     self._drop_db()
     self.original = MongoDict("original",
                               mongo_host=MONGO_HOST,
                               mongo_port=MONGO_PORT)
     self.original["val1"] = 55
     self.original["val2"] = "hello"
     self.fork1 = self.original.fork("fork1")
     self.fork1["val3"] = 65
     self.fork2 = self.fork1.fork("fork2")
     del self.fork2["val1"]
     del self.fork2["val2"]
     del self.fork2["val3"]
Exemple #4
0
class ForkedMongoDictTests(unittest.TestCase):
    def setUp(self):
        self.original = MongoDict(mongo_host=MONGO_HOST, mongo_port=MONGO_PORT)
        self.fork = self.original.fork()

    def test_mongo_dict_len(self):
        test = CheckDict(self, self.fork)
        test.test_len()

    def test_mongo_dict_keys(self):
        test = CheckDict(self, self.fork)
        test.test_keys()

    def test_mongo_dict_write_read(self):
        test = CheckDict(self, self.fork)
        test.test_write_read()

    def test_mongo_dict_write_read_complex_data(self):
        test = CheckDict(self, self.fork)
        test.test_write_read_complex_data()

    def test_mongo_dict_contains(self):
        test = CheckDict(self, self.fork)
        test.test_contains()

    def test_mongo_dict_delete(self):
        test = CheckDict(self, self.fork)
        test.test_delete()

    def test_iter(self):
        test = CheckDict(self, self.fork)
        test.test_iter()

    def test_items(self):
        test = CheckDict(self, self.fork)
        test.test_items()

    def test_update(self):
        test = CheckDict(self, self.fork)
        test.test_update()

    def test_query(self):
        test = CheckDict(self, self.fork)
        test.test_query()

    def tearDown(self):
        self.dropper = DictDropper(mongo_host=MONGO_HOST,
                                   mongo_port=MONGO_PORT)
        self.dropper.drop_dict(self.original.get_my_id())
        self.dropper.drop_dict(self.fork.get_my_id())
Exemple #5
0
class ForkSituationsTest(unittest.TestCase):
    def setUp(self):
        self._drop_db()
        self.original = MongoDict("original",
                                  mongo_host=MONGO_HOST,
                                  mongo_port=MONGO_PORT)
        self.original2 = MongoDict("original",
                                   mongo_host=MONGO_HOST,
                                   mongo_port=MONGO_PORT)
        self.fork1 = self.original.fork("fork1")

    def test_similar_dicts(self):
        self.assertEqual(self.original, self.original2)

    def test_fork_reflected_on_originals(self):
        sleep(1.5)

        self.original2['foo'] = 'bar'
        self.assertEqual(self.original['foo'], 'bar')
        self.assertEqual(type(self.original), ForkedMongoDict)
        self.assertEqual(type(self.original2), ForkedMongoDict)

    def tearDown(self):
        self._drop_db()

    def _drop_db(self):
        try:
            self.dropper = DictDropper(mongo_host=MONGO_HOST,
                                       mongo_port=MONGO_PORT)
            self.dropper.drop_dict("original")
            self.dropper.drop_dict("fork1")

        except:
            pass
Exemple #6
0
class BenchmarkTest(unittest.TestCase):
    def setUp(self):
        self._drop_db()
        self.benchmark = MongoDict("benchmark",
                                   mongo_host=MONGO_HOST,
                                   mongo_port=MONGO_PORT)

    def test_bulk_upsert_vs_non_upsert(self):

        start_upsert = time()

        with self.benchmark.bulk(do_upserts=True) as benchmark:
            for x in range(2000):
                benchmark["value_{}".format(x)] = {'upsert': True, 'id': x}

        stop_upsert = time()
        upsert_total_time = stop_upsert - start_upsert

        with self.benchmark.bulk(do_upserts=False) as benchmark:
            for x in range(2000):
                benchmark["value2_{}".format(x)] = {'upsert': False, 'id': x}

        insert_total_time = time() - stop_upsert
        self.assertLess(insert_total_time, upsert_total_time)

    def tearDown(self):
        self._drop_db()

    def _drop_db(self):
        try:
            self.dropper = DictDropper(mongo_host=MONGO_HOST,
                                       mongo_port=MONGO_PORT)
            self.dropper.drop_dict("benchmark")

        except:
            pass
Exemple #7
0
 def setUp(self):
     self._drop_db()
     self.benchmark = MongoDict("benchmark",
                                mongo_host=MONGO_HOST,
                                mongo_port=MONGO_PORT)
Exemple #8
0
class ForkedMongoDictTests3(unittest.TestCase):
    def setUp(self):
        self._drop_db()
        self.original = MongoDict("original",
                                  mongo_host=MONGO_HOST,
                                  mongo_port=MONGO_PORT)
        self.original["val1"] = 55
        self.original["val2"] = "hello"
        self.fork1 = self.original.fork("fork1")
        self.fork1["val3"] = 65
        self.fork2 = self.fork1.fork("fork2")
        del self.fork2["val1"]
        del self.fork2["val2"]
        del self.fork2["val3"]

    def _assert_original_kept(self):
        self.assertEqual(len(self.original), 2)
        self.assertEqual(self.original['val1'], 55)
        self.assertEqual(self.original['val2'], "hello")

        self.assertEqual(len(self.fork1), 3)
        self.assertEqual(self.fork1['val1'], 55)
        self.assertEqual(self.fork1['val2'], "hello")
        self.assertEqual(self.fork1['val3'], 65)

    def test_mongo_dict_len(self):
        test = CheckDict(self, self.fork2)
        test.test_len()
        self._assert_original_kept()

    def test_mongo_dict_keys(self):
        test = CheckDict(self, self.fork2)
        test.test_keys()
        self._assert_original_kept()

    def test_mongo_dict_write_read(self):
        test = CheckDict(self, self.fork2)
        test.test_write_read()
        self._assert_original_kept()

    def test_mongo_dict_write_read_complex_data(self):
        test = CheckDict(self, self.fork2)
        test.test_write_read_complex_data()
        self._assert_original_kept()

    def test_mongo_dict_contains(self):
        test = CheckDict(self, self.fork2)
        test.test_contains()
        self._assert_original_kept()

    def test_mongo_dict_delete(self):
        test = CheckDict(self, self.fork2)
        test.test_delete()
        self._assert_original_kept()

    def test_iter(self):
        test = CheckDict(self, self.fork2)
        test.test_iter()
        self._assert_original_kept()

    def test_items(self):
        test = CheckDict(self, self.fork2)
        test.test_items()
        self._assert_original_kept()

    def test_update(self):
        test = CheckDict(self, self.fork2)
        test.test_update()
        self._assert_original_kept()

    def test_query(self):
        test = CheckDict(self, self.fork2)
        test.test_query()
        self._assert_original_kept()

    def _drop_db(self):
        try:
            self.dropper = DictDropper(mongo_host=MONGO_HOST,
                                       mongo_port=MONGO_PORT)
            self.dropper.drop_dict("original")
            self.dropper.drop_dict("fork1")
            self.dropper.drop_dict("fork2")

        except:
            pass

    def tearDown(self):
        self._drop_db()
Exemple #9
0
 def setUp(self):
     self.original = MongoDict(mongo_host=MONGO_HOST, mongo_port=MONGO_PORT)
     self.fork = self.original.fork()
Exemple #10
0
 def setUp(self):
     self.m = MongoDict(mongo_host=MONGO_HOST, mongo_port=MONGO_PORT)