Makes the app use the redis and statsd clients from utils

app/__init__.py

@@ -6,17 +6,17 @@ from flask import request, url_for, g, jsonify
 from flask.ext.sqlalchemy import SQLAlchemy
 from flask_marshmallow import Marshmallow
 from monotonic import monotonic
+from notifications_utils.clients.statsd.statsd_client import StatsdClient
+from notifications_utils.clients.redis.redis_client import RedisClient
 from notifications_utils import logging, request_id
 from werkzeug.local import LocalProxy
 
 from app.celery.celery import NotifyCelery
 from app.clients import Clients
 from app.clients.email.aws_ses import AwsSesClient
-from app.clients.redis.redis_client import RedisClient
 from app.clients.sms.firetext import FiretextClient
 from app.clients.sms.loadtesting import LoadtestingClient
 from app.clients.sms.mmg import MMGClient
-from app.clients.statsd.statsd_client import StatsdClient
 from app.encryption import Encryption
 
 

app/clients/redis/__init__.py

@@ -1,5 +0,0 @@
-from datetime import datetime
-
-
-def daily_limit_cache_key(service_id):
-    return "{}-{}-{}".format(str(service_id), datetime.utcnow().strftime("%Y-%m-%d"), "count")

app/clients/redis/redis_client.py

@@ -1,40 +0,0 @@
-from flask.ext.redis import FlaskRedis
-from flask import current_app
-
-
-class RedisClient:
-    redis_store = FlaskRedis()
-    active = False
-
-    def init_app(self, app):
-        self.active = app.config.get('REDIS_ENABLED')
-        if self.active:
-            self.redis_store.init_app(app)
-
-    def set(self, key, value, ex=None, px=None, nx=False, xx=False, raise_exception=False):
-        if self.active:
-            try:
-                self.redis_store.set(key, value, ex, px, nx, xx)
-            except Exception as e:
-                current_app.logger.exception(e)
-                if raise_exception:
-                    raise e
-
-    def incr(self, key, raise_exception=False):
-        if self.active:
-            try:
-                return self.redis_store.incr(key)
-            except Exception as e:
-                current_app.logger.exception(e)
-                if raise_exception:
-                    raise e
-
-    def get(self, key, raise_exception=False):
-        if self.active:
-            try:
-                return self.redis_store.get(key)
-            except Exception as e:
-                current_app.logger.exception(e)
-                if raise_exception:
-                    raise e
-        return None

app/clients/statsd/statsd_client.py

@@ -1,31 +0,0 @@
-from statsd import StatsClient
-
-
-class StatsdClient(StatsClient):
-    def init_app(self, app, *args, **kwargs):
-        self.active = app.config.get('STATSD_ENABLED')
-        self.namespace = app.config.get('NOTIFY_ENVIRONMENT') + ".notifications.api."
-
-        if self.active:
-            StatsClient.__init__(
-                self,
-                app.config.get('STATSD_HOST'),
-                app.config.get('STATSD_PORT'),
-                prefix=app.config.get('STATSD_PREFIX')
-            )
-
-    def format_stat_name(self, stat):
-        return self.namespace + stat
-
-    def incr(self, stat, count=1, rate=1):
-        if self.active:
-            super(StatsClient, self).incr(self.format_stat_name(stat), count, rate)
-
-    def timing(self, stat, delta, rate=1):
-        if self.active:
-            super(StatsClient, self).timing(self.format_stat_name(stat), delta, rate)
-
-    def timing_with_dates(self, stat, start, end, rate=1):
-        if self.active:
-            delta = (start - end).total_seconds()
-            super(StatsClient, self).timing(self.format_stat_name(stat), delta, rate)

app/notifications/process_notifications.py

@@ -6,7 +6,7 @@ from notifications_utils.template import Template
 
 from app import redis_store
 from app.celery import provider_tasks
-from app.clients import redis
+from notifications_utils.clients import redis
 from app.dao.notifications_dao import dao_create_notification, dao_delete_notifications_and_history_by_id
 from app.models import SMS_TYPE, Notification, KEY_TYPE_TEST, EMAIL_TYPE
 from app.notifications.validators import check_sms_content_char_count

app/notifications/validators.py

@@ -5,7 +5,7 @@ from app.models import KEY_TYPE_TEST, KEY_TYPE_TEAM
 from app.service.utils import service_allowed_to_send_to
 from app.v2.errors import TooManyRequestsError, BadRequestError
 from app import redis_store
-from app.clients import redis
+from notifications_utils.clients import redis
 
 
 def check_service_message_limit(key_type, service):

tests/app/clients/test_redis_client.py

@@ -1,81 +0,0 @@
-import pytest
-from unittest.mock import Mock
-
-from app.clients.redis.redis_client import RedisClient
-from app.clients.redis import daily_limit_cache_key
-from freezegun import freeze_time
-
-
-@pytest.fixture(scope='function')
-def enabled_redis_client(notify_api, mocker):
-    notify_api.config['REDIS_ENABLED'] = True
-    return build_redis_client(notify_api, mocker)
-
-
-@pytest.fixture(scope='function')
-def disabled_redis_client(notify_api, mocker):
-    notify_api.config['REDIS_ENABLED'] = False
-    return build_redis_client(notify_api, mocker)
-
-
-def build_redis_client(notify_api, mocker):
-    redis_client = RedisClient()
-    redis_client.init_app(notify_api)
-    mocker.patch.object(redis_client.redis_store, 'get', return_value=100)
-    mocker.patch.object(redis_client.redis_store, 'set')
-    return redis_client
-
-
-def test_should_not_raise_exception_if_raise_set_to_false(notify_api):
-    notify_api.config['REDIS_ENABLED'] = True
-    redis_client = RedisClient()
-    redis_client.init_app(notify_api)
-    redis_client.redis_store.get = Mock(side_effect=Exception())
-    redis_client.redis_store.set = Mock(side_effect=Exception())
-    redis_client.redis_store.incr = Mock(side_effect=Exception())
-    assert redis_client.get('test') is None
-    assert redis_client.set('test', 'test') is None
-    assert redis_client.incr('test') is None
-
-
-def test_should_raise_exception_if_raise_set_to_true(notify_api):
-    notify_api.config['REDIS_ENABLED'] = True
-    redis_client = RedisClient()
-    redis_client.init_app(notify_api)
-    redis_client.redis_store.get = Mock(side_effect=Exception('get failed'))
-    redis_client.redis_store.set = Mock(side_effect=Exception('set failed'))
-    redis_client.redis_store.incr = Mock(side_effect=Exception('inc failed'))
-    with pytest.raises(Exception) as e:
-        redis_client.get('test', raise_exception=True)
-    assert str(e.value) == 'get failed'
-    with pytest.raises(Exception) as e:
-        redis_client.set('test', 'test', raise_exception=True)
-    assert str(e.value) == 'set failed'
-    with pytest.raises(Exception) as e:
-        redis_client.incr('test', raise_exception=True)
-    assert str(e.value) == 'inc failed'
-
-
-def test_should_not_call_set_if_not_enabled(disabled_redis_client):
-    assert not disabled_redis_client.set('key', 'value')
-    disabled_redis_client.redis_store.set.assert_not_called()
-
-
-def test_should_call_set_if_enabled(enabled_redis_client):
-    enabled_redis_client.set('key', 'value')
-    enabled_redis_client.redis_store.set.assert_called_with('key', 'value', None, None, False, False)
-
-
-def test_should_not_call_get_if_not_enabled(disabled_redis_client):
-    disabled_redis_client.set('key', 'value')
-    disabled_redis_client.redis_store.get.assert_not_called()
-
-
-def test_should_call_get_if_enabled(enabled_redis_client):
-    assert enabled_redis_client.get('key') == 100
-    enabled_redis_client.redis_store.get.assert_called_with('key')
-
-
-def test_should_build_cache_key_service_and_action(sample_service):
-    with freeze_time("2016-01-01 12:00:00.000000"):
-        assert daily_limit_cache_key(sample_service.id) == '{}-2016-01-01-count'.format(sample_service.id)