Remove mixed-in interfaces

CiscoZeus · Jun 4, 2017 · e2fdf2f · e2fdf2f
1 parent 12ffe70
commit e2fdf2f
Show file tree

Hide file tree

Showing 9 changed files with 549 additions and 431 deletions.
diff --git a/Makefile b/Makefile
@@ -35,10 +35,10 @@ clean-test:
 	rm -fr htmlcov/
 
 lint:
-	flake8 zeus tests
+	@flake8 zeus tests
 
 test:
-	python setup.py test
+	@python setup.py test
 
 test-all:
 	tox

diff --git a/setup.cfg b/setup.cfg
@@ -1,2 +1,5 @@
 [wheel]
 universal = 1
+
+[flake8]
+max-line-length = 90
diff --git a/tests/test_zeus_client.py b/tests/test_zeus_client.py
@@ -23,13 +23,13 @@
 """
 
 import json
-import mock
+from mock import patch
 import posixpath
 import unittest
 import urlparse
 
 from zeus import client
-from zeus.interfaces.utils import validateDates, ZeusException
+from zeus.interfaces.utils import validate_dates, ZeusException
 
 FAKE_TOKEN = 'ZeUsRoCkS'
 FAKE_SERVER = 'https://zeus.rocks'
@@ -43,8 +43,9 @@ def setUp(self):
             'Authorization': "Bearer {}".format(FAKE_TOKEN),
             'content-type': 'application/json'
         }
+        self.fake_bucket_name = 'fake_org/fake_bucket'
 
-    def fake_header_with_z_resource(self, bucket_name):
+    def fake_header_with_bucket_name(self, bucket_name):
         """
         Make HTTP Header
         :param bucket_name: bucket name
@@ -56,49 +57,66 @@ def fake_header_with_z_resource(self, bucket_name):
 
     def test_initialization_no_https(self):
         z = client.ZeusClient(FAKE_TOKEN, "zeus.rocks")
-        assert z.server == "https://zeus.rocks"
+        assert z.endpoint == "https://zeus.rocks"
+
         z = client.ZeusClient(FAKE_TOKEN, "http://zeus.rocks")
-        assert z.server == "https://zeus.rocks"
+        assert z.endpoint == "https://zeus.rocks"
 
     def test_validate_dates(self):
         # normal
         from_date = 12345
         to_date = 12346
-        validateDates(from_date, to_date)
+        validate_dates(from_date, to_date)
         # None value
         from_date = None
         to_date = 12346
-        validateDates(from_date, to_date)
+        validate_dates(from_date, to_date)
         # invalid value
         from_date = 'wrongvalue'
         to_date = 12346
         self.assertRaises(
-            ZeusException, validateDates, from_date, to_date)
+            ZeusException, validate_dates, from_date, to_date)
         # inversed order
         from_date = 12346
         to_date = 12345
         self.assertRaises(
-            ZeusException, validateDates, from_date, to_date)
+            ZeusException, validate_dates, from_date, to_date)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_post_empty_log(self, mock_requests):
         logs = []
-        url = urlparse.urljoin(FAKE_SERVER,
-                               posixpath.join('logs', FAKE_TOKEN, 'ZeusTest'))
+        url = urlparse.urljoin(
+            FAKE_SERVER, posixpath.join('logs', FAKE_TOKEN, 'ZeusTest'))
+
         self.z.sendLog('ZeusTest', logs)
         mock_requests.post.assert_called_with(
             url, data={"logs": json.dumps(logs)},
-            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
+            headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_post_single_log(self, mock_requests):
         url = urlparse.urljoin(
             FAKE_SERVER, posixpath.join('logs', FAKE_TOKEN, 'ZeusTest'))
         logs = [{"timestamp": 123541423, "key": "TestLog", "key2": 123}]
         self.z.sendLog('ZeusTest', logs)
         mock_requests.post.assert_called_with(
             url, data={"logs": json.dumps(logs)},
-            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
+            headers=self.fake_headers, timeout=20)
+
+    @patch('zeus.client.requests')
+    def test_send_log_with_bucket_name(self, mock_requests):
+        url = urlparse.urljoin(
+            FAKE_SERVER, posixpath.join('logs', FAKE_TOKEN, 'ZeusTest'))
+        logs = [{"timestamp": 123541423, "key": "TestLog", "key2": 123}]
+
+        self.z.bucket(self.fake_bucket_name).sendLog('ZeusTest', logs)
+
+        mock_requests.post.assert_called_with(
+            url, data={"logs": json.dumps(logs)},
+            headers=self.fake_header_with_bucket_name(self.fake_bucket_name),
+            timeout=20)
+
+        self.assertIsNone(self.z.bucket_name)
 
     def test_post_single_log_wrong_name(self):
         logs = [{"message": "TestLog", "value": 23}]
@@ -118,7 +136,7 @@ def test_post_single_log_wrong_name(self):
             ZeusException, self.z.sendLog, '0123456789ABCDEF' * 16,
             logs)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_post_multiple_logs(self, mock_requests):
         url = urlparse.urljoin(
             FAKE_SERVER, posixpath.join('logs', FAKE_TOKEN, 'ZeusTest'))
@@ -128,9 +146,9 @@ def test_post_multiple_logs(self, mock_requests):
         self.z.sendLog('ZeusTest', logs)
         mock_requests.post.assert_called_with(
             url, data={"logs": json.dumps(logs)},
-            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
+            headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_logs(self, mock_requests):
         url = urlparse.urljoin(FAKE_SERVER, posixpath.join('logs', FAKE_TOKEN))
         self.z.getLog('ZeusTest',
@@ -150,27 +168,41 @@ def test_get_logs(self, mock_requests):
                 'to': 126235344235,
                 'offset': 23,
                 'limit': 10},
+            headers=self.fake_headers,
             timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
+    def test_get_logs_with_bucket_name(self, mock_requests):
+        url = urlparse.urljoin(FAKE_SERVER, posixpath.join('logs', FAKE_TOKEN))
+
+        self.z.bucket(self.fake_bucket_name).getLog('ZeusTest')
+        mock_requests.get.assert_called_with(
+            url,
+            params={'log_name': 'ZeusTest'},
+            headers=self.fake_header_with_bucket_name(self.fake_bucket_name),
+            timeout=20
+        )
+        self.assertIsNone(self.z.bucket_name)
+
+    @patch('zeus.client.requests')
     def test_post_empty_metric(self, mock_requests):
         url = urlparse.urljoin(
             FAKE_SERVER, posixpath.join('metrics', FAKE_TOKEN, 'ZeusTest'))
         metrics = []
         self.z.sendMetric('ZeusTest', metrics)
         mock_requests.post.assert_called_with(
             url, data={"metrics": json.dumps(metrics)},
-            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
+            headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_post_single_metric(self, mock_requests):
         url = urlparse.urljoin(
             FAKE_SERVER, posixpath.join('metrics', FAKE_TOKEN, 'Zeus.Test'))
         metrics = [{"timestamp": 123541423, "value": 0}]
         self.z.sendMetric('Zeus.Test', metrics)
         mock_requests.post.assert_called_with(
             url, data={"metrics": json.dumps(metrics)},
-            headers=self.fake_header_with_z_resource('Zeus.Test'),
+            headers=self.fake_headers,
             timeout=20)
 
     def test_post_single_metric_wrong_name(self):
@@ -187,7 +219,7 @@ def test_post_single_metric_wrong_name(self):
             ZeusException, self.z.sendMetric, '0123456789ABCDEF' * 16,
             metrics)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_post_multiple_metrics(self, mock_requests):
         url = urlparse.urljoin(
             FAKE_SERVER, posixpath.join('metrics', FAKE_TOKEN, 'ZeusTest'))
@@ -197,9 +229,9 @@ def test_post_multiple_metrics(self, mock_requests):
         self.z.sendMetric('ZeusTest', metrics)
         mock_requests.post.assert_called_with(
             url, data={"metrics": json.dumps(metrics)},
-            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
+            headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_metric_values(self, mock_requests):
         self.z.getMetric(metric_name='ZeusTest',
                          aggregator_function='sum',
@@ -222,29 +254,35 @@ def test_get_metric_values(self, mock_requests):
                 'group_interval': '1m',
                 'filter_condition': 'value > 90',
                 'limit': 10,
-                'offset': 20}, timeout=20)
+                'offset': 20},
+            headers=self.fake_headers,
+            timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_metric_names(self, mock_requests):
         self.z.getMetricNames(metric_name='ZeusTest',
                               limit=10,
                               offset=20)
-        mock_requests.get.assert_called_with(FAKE_SERVER + '/metrics/' +
-                                             FAKE_TOKEN + '/_names',
-                                             params={'metric_name': 'ZeusTest',
-                                                     'limit': 10,
-                                                     'offset': 20}, timeout=20)
+        mock_requests.get.assert_called_with(
+            FAKE_SERVER + '/metrics/' +
+            FAKE_TOKEN + '/_names',
+            params={'metric_name': 'ZeusTest',
+                    'limit': 10,
+                    'offset': 20},
+            headers=self.fake_headers,
+            timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_delete_metric(self, mock_requests):
         self.z.deleteMetric('ZeusTest')
         mock_requests.delete.assert_called_with(
             FAKE_SERVER + '/metrics/' +
             FAKE_TOKEN + '/ZeusTest',
+            headers=self.fake_headers,
             timeout=20
         )
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_create_alert(self, mock_requests):
         alert_name = "testerino"
         username = "pelegrino"
@@ -278,7 +316,7 @@ def test_create_alert(self, mock_requests):
             FAKE_TOKEN, data=json.dumps(data),
             headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_modify_alert(self, mock_requests):
         alert_id = 42
         alert_name = "testerino"
@@ -313,73 +351,72 @@ def test_modify_alert(self, mock_requests):
             path, data=json.dumps(data),
             headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_alerts(self, mock_requests):
         self.z.getAlerts()
 
         path = FAKE_SERVER + '/alerts/' + FAKE_TOKEN
-        mock_requests.get.assert_called_with(path, params=None, timeout=20)
+        mock_requests.get.assert_called_with(
+            path, params=None, headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_alert(self, mock_requests):
         alert_id = 42
         self.z.getAlert(alert_id)
 
         path = FAKE_SERVER + '/alerts/' + FAKE_TOKEN + '/' + str(alert_id)
-        mock_requests.get.assert_called_with(path, params=None, timeout=20)
+        mock_requests.get.assert_called_with(
+            path, params=None, headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_delete_alert(self, mock_requests):
         alert_id = 42
         self.z.deleteAlert(alert_id)
 
         path = FAKE_SERVER + '/alerts/' + FAKE_TOKEN + '/' + str(alert_id)
-        mock_requests.delete.assert_called_with(path, timeout=20)
+        mock_requests.delete.assert_called_with(
+            path, headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_enable_alerts(self, mock_requests):
         alert_id_list = [19, 42]
         self.z.enableAlerts(alert_id_list)
-        data = {
-            'id': alert_id_list
-        }
+        data = {'id': alert_id_list}
 
         path = FAKE_SERVER + '/alerts/' + FAKE_TOKEN + '/enable'
         mock_requests.post.assert_called_with(
-            path, data=json.dumps(data),
-            headers=self.fake_headers, timeout=20)
+            path, data=json.dumps(data), headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_disable_alerts(self, mock_requests):
         alert_id_list = [19, 42]
         self.z.disableAlerts(alert_id_list)
-        data = {
-            'id': alert_id_list
-        }
+        data = {'id': alert_id_list}
 
         path = FAKE_SERVER + '/alerts/' + FAKE_TOKEN + '/disable'
         mock_requests.post.assert_called_with(
-            path, data=json.dumps(data),
-            headers=self.fake_headers, timeout=20)
+            path, data=json.dumps(data), headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_triggered_alerts(self, mock_requests):
         self.z.getTriggeredAlerts()
 
         path = FAKE_SERVER + '/triggeredalerts/' + FAKE_TOKEN
-        mock_requests.get.assert_called_with(path, params=None, timeout=20)
+        mock_requests.get.assert_called_with(
+            path, params=None, headers=self.fake_headers, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def test_get_triggered_alerts_last_24h(self, mock_requests):
         self.z.getTriggeredAlertsLast24Hours()
 
         path = FAKE_SERVER + '/triggeredalerts/' + FAKE_TOKEN + "/last24"
-        mock_requests.get.assert_called_with(path, params=None, timeout=20)
+        mock_requests.get.assert_called_with(
+            path, params=None, headers=self.fake_headers, timeout=20)
 
     def test_get_delete_metric_wrong_name(self):
         self.assertRaises(ZeusException, self.z.deleteMetric, '_WrongName')
 
-    @mock.patch('zeus.interfaces.rest.requests')
+    @patch('zeus.client.requests')
     def tearDown(self, mock_requests):
         pass