Update test code for Bucket-Name Header

.gitignore

@@ -9,7 +9,6 @@
 dist
 build
 eggs
-.eggs
 parts
 bin
 var
@@ -19,6 +18,9 @@ develop-eggs
 lib
 lib64
 
+# pyenv
+.python-version
+
 # Installer logs
 pip-log.txt
 

test_requirements.txt

@@ -1,8 +1,7 @@
 tox
-flake8
 mock
 pytest
 pytest-cov
 
 #docs
-Sphinx
+Sphinx

tests/test_zeus_client.py

@@ -42,6 +42,16 @@ def setUp(self):
             'content-type': 'application/json'
         }
 
+    def fake_header_with_z_resource(self, bucket_name):
+        """
+        Make HTTP Header
+        :param bucket_name: bucket name
+        :type bucket_name: str
+        :return: Header Object
+        :rtype: dict
+        """
+        return dict(self.fake_headers, **{'Bucket-Name': bucket_name})
+
     def test_initialization_no_https(self):
         z = client.ZeusClient(FAKE_TOKEN, "zeus.rocks")
         assert z.server == "https://zeus.rocks"
@@ -71,25 +81,22 @@ def test_validate_dates(self):
     @mock.patch('zeus.interfaces.rest.requests')
     def test_post_empty_log(self, mock_requests):
         logs = []
+        url = '{}/logs/{}/ZeusTest'.format(FAKE_SERVER, FAKE_TOKEN)
         self.z.sendLog('ZeusTest', logs)
-        mock_requests.post.assert_called_with(FAKE_SERVER + '/logs/' +
-                                              FAKE_TOKEN + '/ZeusTest/',
-                                              data={"logs": json.dumps(logs)},
-                                              headers=self.fake_headers,
-                                              timeout=20)
+        mock_requests.post.assert_called_with(
+            url, data={"logs": json.dumps(logs)},
+            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_post_single_log(self, mock_requests):
+        url = '{}/logs/{}/ZeusTest'.format(FAKE_SERVER, FAKE_TOKEN)
         logs = [{"timestamp": 123541423, "key": "TestLog", "key2": 123}]
         self.z.sendLog('ZeusTest', logs)
-        mock_requests.post.assert_called_with(FAKE_SERVER + '/logs/' +
-                                              FAKE_TOKEN + '/ZeusTest/',
-                                              data={"logs": json.dumps(logs)},
-                                              headers=self.fake_headers,
-                                              timeout=20)
+        mock_requests.post.assert_called_with(
+            url, data={"logs": json.dumps(logs)},
+            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
-    def test_post_single_log_wrong_name(self, mock_requests):
+    def test_post_single_log_wrong_name(self):
         logs = [{"message": "TestLog", "value": 23}]
         self.assertRaises(
             ZeusException, self.z.sendLog, 'W.rongName', logs)
@@ -109,60 +116,57 @@ def test_post_single_log_wrong_name(self, mock_requests):
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_post_multiple_logs(self, mock_requests):
+        url = '{}/logs/{}/ZeusTest'.format(FAKE_SERVER, FAKE_TOKEN)
         logs = [{"timestamp": 123541423, "message": "TestLog"},
                 {"timestamp": 123541424, "message": "TestLog2"},
                 {"timestamp": 123541425, "message": "TestLog3"}, ]
         self.z.sendLog('ZeusTest', logs)
-        mock_requests.post.assert_called_with(FAKE_SERVER + '/logs/' +
-                                              FAKE_TOKEN + '/ZeusTest/',
-                                              data={"logs": json.dumps(logs)},
-                                              headers=self.fake_headers,
-                                              timeout=20)
+        mock_requests.post.assert_called_with(
+            url, data={"logs": json.dumps(logs)},
+            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_get_logs(self, mock_requests):
+        url = '{}/logs/{}'.format(FAKE_SERVER, FAKE_TOKEN)
         self.z.getLog('ZeusTest',
                       attribute_name='message',
                       pattern='*',
                       from_date=123456789,
                       to_date=126235344235,
                       offset=23,
                       limit=10)
-        mock_requests.get.assert_called_with(FAKE_SERVER + '/logs/' +
-                                             FAKE_TOKEN + '/',
-                                             params={'log_name': 'ZeusTest',
-                                                     'attribute_name':
-                                                         'message',
-                                                     'pattern': '*',
-                                                     'from': 123456789,
-                                                     'to': 126235344235,
-                                                     'offset': 23,
-                                                     'limit': 10}, timeout=20)
+        mock_requests.get.assert_called_with(
+            url,
+            params={
+                'log_name': 'ZeusTest',
+                'attribute_name': 'message',
+                'pattern': '*',
+                'from': 123456789,
+                'to': 126235344235,
+                'offset': 23,
+                'limit': 10},
+            timeout=20)
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_post_empty_metric(self, mock_requests):
+        url = '{}/metrics/{}/ZeusTest'.format(FAKE_SERVER, FAKE_TOKEN)
         metrics = []
         self.z.sendMetric('ZeusTest', metrics)
-        mock_requests.post.assert_called_with(FAKE_SERVER + '/metrics/' +
-                                              FAKE_TOKEN + '/ZeusTest/',
-                                              data={"metrics":
-                                                        json.dumps(metrics)},
-                                              headers=self.fake_headers,
-                                              timeout=20)
+        mock_requests.post.assert_called_with(
+            url, data={"metrics": json.dumps(metrics)},
+            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_post_single_metric(self, mock_requests):
+        url = '{}/metrics/{}/Zeus.Test'.format(FAKE_SERVER, FAKE_TOKEN)
         metrics = [{"timestamp": 123541423, "value": 0}]
         self.z.sendMetric('Zeus.Test', metrics)
-        mock_requests.post.assert_called_with(FAKE_SERVER + '/metrics/' +
-                                              FAKE_TOKEN + '/Zeus.Test/',
-                                              data={"metrics":
-                                                        json.dumps(metrics)},
-                                              headers=self.fake_headers,
-                                              timeout=20)
+        mock_requests.post.assert_called_with(
+            url, data={"metrics": json.dumps(metrics)},
+            headers=self.fake_header_with_z_resource('Zeus.Test'),
+            timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
-    def test_post_single_metric_wrong_name(self, mock_requests):
+    def test_post_single_metric_wrong_name(self):
         metrics = [{"timestamp": 123541423, "value": 0}]
         self.assertRaises(
             ZeusException, self.z.sendMetric, '_WrongName', metrics)
@@ -178,16 +182,14 @@ def test_post_single_metric_wrong_name(self, mock_requests):
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_post_multiple_metrics(self, mock_requests):
+        url = '{}/metrics/{}/ZeusTest'.format(FAKE_SERVER, FAKE_TOKEN)
         metrics = [{"timestamp": 123541423, "value": 0},
                    {"timestamp": 123541424, "value": 1},
                    {"timestamp": 123541425, "value": 2.0}, ]
         self.z.sendMetric('ZeusTest', metrics)
-        mock_requests.post.assert_called_with(FAKE_SERVER + '/metrics/' +
-                                              FAKE_TOKEN + '/ZeusTest/',
-                                              data={"metrics":
-                                                        json.dumps(metrics)},
-                                              headers=self.fake_headers,
-                                              timeout=20)
+        mock_requests.post.assert_called_with(
+            url, data={"metrics": json.dumps(metrics)},
+            headers=self.fake_header_with_z_resource('ZeusTest'), timeout=20)
 
     @mock.patch('zeus.interfaces.rest.requests')
     def test_get_metric_values(self, mock_requests):
@@ -200,28 +202,27 @@ def test_get_metric_values(self, mock_requests):
                          filter_condition='value > 90',
                          limit=10,
                          offset=20)
-        mock_requests.get.assert_called_with(FAKE_SERVER + '/metrics/' +
-                                             FAKE_TOKEN + '/_values/',
-                                             params={'metric_name': 'ZeusTest',
-                                                     'aggregator_function':
-                                                         'sum',
-                                                     'aggregator_column':
-                                                         'val1',
-                                                     'from': 123456789,
-                                                     'to': 126235344235,
-                                                     'group_interval': '1m',
-                                                     'filter_condition':
-                                                         'value > 90',
-                                                     'limit': 10,
-                                                     'offset': 20}, timeout=20)
+        mock_requests.get.assert_called_with(
+            FAKE_SERVER + '/metrics/' +
+            FAKE_TOKEN + '/_values',
+            params={
+                'metric_name': 'ZeusTest',
+                'aggregator_function': 'sum',
+                'aggregator_column': 'val1',
+                'from': 123456789,
+                'to': 126235344235,
+                'group_interval': '1m',
+                'filter_condition': 'value > 90',
+                'limit': 10,
+                'offset': 20}, timeout=20)
 
     @mock.patch('zeus.interfaces.rest.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/',
+                                             FAKE_TOKEN + '/_names',
                                              params={'metric_name': 'ZeusTest',
                                                      'limit': 10,
                                                      'offset': 20}, timeout=20)
@@ -231,7 +232,7 @@ def test_get_delete_metric(self, mock_requests):
         self.z.deleteMetric('ZeusTest')
         mock_requests.delete.assert_called_with(
             FAKE_SERVER + '/metrics/' +
-            FAKE_TOKEN + '/ZeusTest/',
+            FAKE_TOKEN + '/ZeusTest',
             timeout=20
         )
 
@@ -367,10 +368,8 @@ def test_get_triggered_alerts_last_24h(self, mock_requests):
         path = FAKE_SERVER + '/triggeredalerts/' + FAKE_TOKEN + "/last24"
         mock_requests.get.assert_called_with(path, params=None, timeout=20)
 
-    @mock.patch('zeus.interfaces.rest.requests')
-    def test_get_delete_metric_wrong_name(self, mock_requests):
-        self.assertRaises(
-            ZeusException, self.z.deleteMetric, '_WrongName')
+    def test_get_delete_metric_wrong_name(self):
+        self.assertRaises(ZeusException, self.z.deleteMetric, '_WrongName')
 
     @mock.patch('zeus.interfaces.rest.requests')
     def tearDown(self, mock_requests):

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py26, py27, pep8
+envlist = py27, pep8
 
 [testenv]
 setenv =
@@ -22,4 +22,4 @@ commands =
 
 [flake8]
 show-source = True
-exclude = .tox,docs/*,setup.py,*.egg
+exclude = .tox,docs/*,setup.py,*.egg

zeus/interfaces/alerts.py

@@ -69,7 +69,7 @@ def getAlerts(self):
 
         :rtype: array
         """
-        path = '/alerts/' + self.token
+        path = '/alerts/{}'.format(self.token)
         return self.rest_client.sendGetRequest(path)
 
     def modifyAlert(
@@ -106,7 +106,7 @@ def modifyAlert(
             'status': status,
             'notify_period': notify_period
         }
-        path = '/alerts/' + self.token + '/' + str(alert_id)
+        path = '/alerts/{}/{}'.format(self.token, str(alert_id))
 
         return self.rest_client.sendPutRequest(
             path, json.dumps(data), self.headers)
@@ -118,7 +118,8 @@ def getAlert(self, alert_id):
 
         :rtype: array
         """
-        path = '/alerts/' + self.token + '/' + str(alert_id)
+        path = '/alerts/{}/{}'.format(self.token, str(alert_id))
+
         return self.rest_client.sendGetRequest(path)
 
     def deleteAlert(self, alert_id):
@@ -128,7 +129,8 @@ def deleteAlert(self, alert_id):
 
         :rtype: array
         """
-        path = '/alerts/' + self.token + '/' + str(alert_id)
+        path = '/alerts/{}/{}'.format(self.token, str(alert_id))
+
         return self.rest_client.sendDeleteRequest(path)
 
     def enableAlerts(self, alert_id_list):
@@ -138,10 +140,8 @@ def enableAlerts(self, alert_id_list):
 
         :rtype: array
         """
-        data = {
-            'id': alert_id_list
-        }
-        path = '/alerts/' + self.token + '/enable'
+        path = '/alerts/{}/enable'.format(self.token)
+        data = {'id': alert_id_list}
 
         return self.rest_client.sendPostRequest(
             path, json.dumps(data), self.headers)
@@ -153,11 +153,8 @@ def disableAlerts(self, alert_id_list):
 
         :rtype: array
         """
-
-        data = {
-            'id': alert_id_list
-        }
-        path = '/alerts/' + self.token + '/disable'
+        path = '/alerts/{}/disable'.format(self.token)
+        data = {'id': alert_id_list}
 
         return self.rest_client.sendPostRequest(
             path, json.dumps(data), self.headers)

zeus/interfaces/logs.py

@@ -36,12 +36,13 @@ def sendLog(self, log_name, logs):
         :rtype: dict
 
         """
-        url = '/logs/{}/{}/'.format(self.token, log_name)
+        url = '/logs/{}/{}'.format(self.token, log_name)
 
         validateLogName(log_name)
         data = {'logs': json.dumps(logs)}
 
-        return self.rest_client.sendPostRequest(url, data, self.headers)
+        return self.rest_client.sendPostRequest(
+            url, data, self.__build_header(log_name))
 
     def getLog(self, log_name, attribute_name=None, pattern=None,
                from_date=None, to_date=None, offset=None, limit=None):
@@ -58,7 +59,7 @@ def getLog(self, log_name, attribute_name=None, pattern=None,
         :rtype: array
 
         """
-        url = '/logs/{}/'.format(self.token)
+        url = '/logs/{}'.format(self.token)
 
         validateDates(from_date, to_date)
         data = {"log_name": log_name}
@@ -75,4 +76,15 @@ def getLog(self, log_name, attribute_name=None, pattern=None,
         if limit:
             data['limit'] = limit
 
-        return self.rest_client.sendGetRequest(url, data, self.headers)
+        return self.rest_client.sendGetRequest(
+            url, data, self.__build_header(log_name))
+
+    def __build_header(self, bucket_name):
+        """
+        Make HTTP Header
+        :param bucket_name: bucket name
+        :type bucket_name: str
+        :return: Header Object
+        :rtype: dict
+        """
+        return dict(self.headers, **{'Bucket-Name': bucket_name})