Add initial rate-limit functionality

Likely needs more tests, but that's all I'm getting done tonight.

test/mongo_test.py

@@ -6,10 +6,13 @@ from metrik.targets.mongo import MongoTarget
 
 
 class MongoTest(TestCase):
+    def setUp(self):
+        self.client = MongoClient(MONGO_HOST, MONGO_PORT)
+        self.db = self.client[MONGO_DATABASE]
+
     def tearDown(self):
         super(MongoTest, self).tearDown()
-        client = MongoClient(MONGO_HOST, MONGO_PORT)
-        client.drop_database(MONGO_DATABASE)
+        self.client.drop_database(MONGO_DATABASE)
 
 
 class MongoTestTest(MongoTest):

test/tasks/test_base.py

@@ -1,11 +1,94 @@
 from unittest import TestCase
-from datetime import datetime
+from datetime import datetime, timedelta
 
-from metrik.tasks.base import MongoNoBackCreateTask
+from metrik.tasks.base import MongoNoBackCreateTask, MongoRateLimit
+from test.mongo_test import MongoTest
 
 
 class BaseTaskTest(TestCase):
-
     def test_mongo_no_back_live_false(self):
+        # Test that default for `live` parameter is False
         task = MongoNoBackCreateTask(current_datetime=datetime.now())
-        assert not task.live
+        assert not task.live
+
+
+class RateLimitTest(MongoTest):
+    def test_save_creates_record(self):
+        service = 'testing_ratelimit'
+        assert self.db[MongoRateLimit.rate_limit_collection].count() == 0
+
+        present = datetime.now()
+        onesec_back = present - timedelta(seconds=1)
+        ratelimit = MongoRateLimit(
+            service, 1, timedelta(seconds=1)
+        )
+        assert ratelimit.query_locks(onesec_back) == 0
+
+        ratelimit.save_lock(present)
+        assert self.db[service].count() == 1
+        assert ratelimit.query_locks(onesec_back) == 1
+
+    def test_save_creates_correct_service(self):
+        service_1 = 'testing_ratelimit_1'
+        service_2 = 'testing_ratelimit_2'
+
+        ratelimit1 = MongoRateLimit(
+            service_1, 1, timedelta(seconds=1)
+        )
+        ratelimit2 = MongoRateLimit(
+            service_2, 1, timedelta(seconds=1)
+        )
+
+        present = datetime.now()
+        assert self.db[MongoRateLimit.rate_limit_collection].count() == 0
+        assert ratelimit1.query_locks(present) == 0
+        assert ratelimit2.query_locks(present) == 0
+
+        ratelimit1.save_lock(present)
+        assert self.db[MongoRateLimit.rate_limit_collection].count() == 1
+        assert ratelimit1.query_locks(present) == 1
+        assert ratelimit2.query_locks(present) == 0
+
+    def test_acquire_lock_fails(self):
+        service = 'testing_ratelimit'
+
+        # The first scenario is as follows:
+        # We try to acquire a lock with 1 try, backoff is 10.
+        # We are checking for locks up to 1 second ago, and there
+        # is a lock in the database from a half-second ago. Thus,
+        # we should fail immediately since we did not acquire the
+        # lock and are only allowed one try.
+        # Ultimately, we are testing that the 'fail immediately'
+        # switch gets triggered correctly
+        ratelimit = MongoRateLimit(
+            service, 1, timedelta(seconds=1), max_tries=1, backoff=10
+        )
+
+        start = datetime.now()
+        ratelimit.save_lock(start)
+        did_acquire = ratelimit.acquire_lock()
+        end = datetime.now()
+        assert not did_acquire
+        assert (end - start).total_seconds() < 1
+
+    def test_acquire_lock_succeeds(self):
+        service = 'testing_ratelimit'
+
+        # The first scenario is as follows:
+        # We try to acquire a lock with two tries, backoff is 1.
+        # We put a single lock in initially (a half second in the past),
+        # thus when we try to acquire on the first try, we should fail.
+        # However, the backoff should kick in, and we acquire successfully
+        # on the second try
+        ratelimit = MongoRateLimit(
+            service, 1, timedelta(seconds=1), max_tries=2, backoff=1
+        )
+
+        start = datetime.now()
+        ratelimit.save_lock(start - timedelta(seconds=.5))
+        did_acquire = ratelimit.acquire_lock()
+        end = datetime.now()
+        # Check that we acquired the lock
+        assert did_acquire
+        # Check that we only used one backoff period
+        assert (end - start).total_seconds() < 2