Adding twine to dev_requirements

* #83 - Fixing the bug that was preventing the status update

* #83 - Refactoring unit tests for configuration to ensure we catch more cases

.circleci/config.yml

@@ -30,7 +30,6 @@ jobs:
             source bin/activate
             pip3 install -r dev_requirements.txt
             pip3 install -r requirements.txt
-            python3 setup.py install
             pip3 install coveralls
 
       - save_cache:
@@ -42,7 +41,7 @@ jobs:
           name: run tests
           command: |
             . bin/activate
-            py.test tests --junitxml=test-reports/junit.xml --cov=cachet_url_monitor
+            python -m pytest tests --junitxml=test-reports/junit.xml --cov=cachet_url_monitor
             coveralls
             coverage xml
             python-codacy-coverage -r coverage.xml

.codacy.yml

@@ -0,0 +1,5 @@
+---
+engines:
+ pylint:
+   enabled: true
+   python_version: 3

README.md

@@ -106,7 +106,7 @@ By choosing any of the aforementioned statuses, it will let you control the kind
 
 The application should be installed using **virtualenv**, through the following command:
 
-```
+```bash
 $ git clone https://github.com/mtakaki/cachet-url-monitor.git
 $ virtualenv cachet-url-monitor
 $ cd cachet-url-monitor
@@ -117,7 +117,7 @@ $ python3 setup.py install
 
 To start the agent:
 
-```
+```bash
 $ python3 cachet_url_monitor/scheduler.py config.yml
 ```
 
@@ -127,22 +127,46 @@ You can run the agent in docker, so you won't need to worry about installing pyt
 
 You have two choices, checking this repo out and building the docker image or it can be pulled directly from [dockerhub](https://hub.docker.com/r/mtakaki/cachet-url-monitor/). You will need to create your own custom `config.yml` file and run (it will pull latest):
 
-```
+```bash
 $ docker pull mtakaki/cachet-url-monitor
 $ docker run --rm -it -v "$PWD":/usr/src/app/config/ mtakaki/cachet-url-monitor
 ```
 
 If you're going to use a file with a name other than `config.yml`, you will need to map the local file, like this:
 
-```
+```bash
 $ docker run --rm -it -v "$PWD"/my_config.yml:/usr/src/app/config/config.yml:ro mtakaki/cachet-url-monitor
 ```
 
+## Generating configuration from existing CachetHQ instance (since 0.6.2)
+ 
+In order to expedite the creation of your configuration file, you can use the client to automatically scrape the CachetHQ instance and spit out a YAML file. It can be used like this:
+```bash
+$ python cachet_url_monitor/client.py http://localhost/api/v1 my-token test.yml
+``` 
+Or from docker (you will end up with a `test.yml` in your `$PWD/tmp` folder):
+```bash
+$ docker run --rm -it -v $PWD/tmp:/home/tmp/ mtakaki/cachet-url-monitor python3.7 ./cachet_url_monitor/client.py http://localhost/api/v1 my-token /home/tmp/test.yml
+```
+The arguments are:
+- **URL**, the CachetHQ API URL, so that means appending `/api/v1` to your hostname.
+- **token**, the token that has access to your CachetHQ instance.
+- **filename**, the file where it should write the configuration.
+
+### Caveats
+Because we can't predict what expectations will be needed, it will default to these behavior:
+- Verify a [200-300[ HTTP status range.
+- If status fail, make the incident major and public.
+- Frequency of 30 seconds.
+- `GET` request.
+- Timeout of 1s.
+- We'll read the `link` field from the components and use it as the URL. 
+
 ## Troubleshooting
 
 ### SSLERROR
 If it's throwing the following exception:
-```
+```python
 raise SSLError(e, request=request)
 requests.exceptions.SSLError: HTTPSConnectionPool(host='redacted', port=443): Max retries exceeded with url: /api/v1/components/19 (Caused by SSLError(SSLError(1, u'[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:579)'),))
 ```

cachet_url_monitor/client.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python
+from typing import Dict
+from typing import Optional
+
+import click
+import requests
+from yaml import dump
+from cachet_url_monitor import latency_unit, status, exceptions
+
+
+def normalize_url(url: str) -> str:
+    """If passed url doesn't include schema return it with default one - http."""
+    if not url.lower().startswith('http'):
+        return f'http://{url}'
+    return url
+
+
+def save_config(config_map, filename: str):
+    with open(filename, 'w') as file:
+        dump(config_map, file)
+
+
+class CachetClient(object):
+    """Utility class to interact with CahetHQ server."""
+    url: str
+    token: str
+    headers: Dict[str, str]
+
+    def __init__(self, url: str, token: str):
+        self.url = normalize_url(url)
+        self.token = token
+        self.headers = {'X-Cachet-Token': token}
+
+    def get_components(self):
+        """Retrieves all components registered in cachet-hq"""
+        return requests.get(f"{self.url}/components", headers=self.headers).json()['data']
+
+    def get_metrics(self):
+        """Retrieves all metrics registered in cachet-hq"""
+        return requests.get(f"{self.url}/metrics", headers=self.headers).json()['data']
+
+    def generate_config(self):
+        components = self.get_components()
+        generated_endpoints = [
+            {
+                'name': component['name'],
+                'url': component['link'],
+                'method': 'GET',
+                'timeout': 1,
+                'expectation': [
+                    {
+                        'type': 'HTTP_STATUS',
+                        'status_range': '200-300',
+                        'incident': 'MAJOR'
+                    }
+                ],
+                'allowed_fails': 0,
+                'frequency': 30,
+                'component_id': component['id'],
+                'action': [
+                    'CREATE_INCIDENT',
+                    'UPDATE_STATUS',
+                ],
+                'public_incidents': True,
+            } for component in components if component['enabled']
+        ]
+        generated_config = {
+            'cachet': {
+                'api_url': self.url,
+                'token': self.token,
+            },
+            'endpoints': generated_endpoints
+        }
+        return generated_config
+
+    def get_default_metric_value(self, metric_id):
+        """Returns default value for configured metric."""
+        get_metric_request = requests.get(f"{self.url}/metrics/{metric_id}", headers=self.headers)
+
+        if get_metric_request.ok:
+            return get_metric_request.json()['data']['default_value']
+        else:
+            raise exceptions.MetricNonexistentError(metric_id)
+
+    def get_component_status(self, component_id: int) -> Optional[status.ComponentStatus]:
+        """Retrieves the current status of the given component. It will fail if the component does
+        not exist or doesn't respond with the expected data.
+        :return component status.
+        """
+        get_status_request = requests.get(f'{self.url}/components/{component_id}', headers=self.headers)
+
+        if get_status_request.ok:
+            # The component exists.
+            return status.ComponentStatus(int(get_status_request.json()['data']['status']))
+        else:
+            raise exceptions.ComponentNonexistentError(component_id)
+
+    def push_status(self, component_id: int, component_status: status.ComponentStatus):
+        """Pushes the status of the component to the cachet server.
+        """
+        params = {'id': component_id, 'status': component_status.value}
+        return requests.put(f"{self.url}/components/{component_id}", params=params, headers=self.headers)
+
+    def push_metrics(self, metric_id: int, latency_time_unit: str, elapsed_time_in_seconds: int, timestamp: int):
+        """Pushes the total amount of seconds the request took to get a response from the URL.
+        """
+        value = latency_unit.convert_to_unit(latency_time_unit, elapsed_time_in_seconds)
+        params = {'id': metric_id, 'value': value, 'timestamp': timestamp}
+        return requests.post(f"{self.url}/metrics/{metric_id}/points", params=params, headers=self.headers)
+
+    def push_incident(self, status_value: status.ComponentStatus, is_public_incident: bool, component_id: int,
+                      previous_incident_id=None, message=None):
+        """If the component status has changed, we create a new incident (if this is the first time it becomes unstable)
+        or updates the existing incident once it becomes healthy again.
+        """
+        if previous_incident_id and status_value == status.ComponentStatus.OPERATIONAL:
+            # If the incident already exists, it means it was unhealthy but now it's healthy again.
+            params = {'status': status.IncidentStatus.FIXED.value, 'visible': is_public_incident,
+                      'component_id': component_id, 'component_status': status_value.value, 'notify': True}
+
+            return requests.put(f'{self.url}/incidents/{previous_incident_id}', params=params, headers=self.headers)
+        elif not previous_incident_id and status_value != status.ComponentStatus.OPERATIONAL:
+            # This is the first time the incident is being created.
+            params = {'name': 'URL unavailable', 'message': message,
+                      'status': status.IncidentStatus.INVESTIGATING.value,
+                      'visible': is_public_incident, 'component_id': component_id, 'component_status': status_value.value,
+                      'notify': True}
+            return requests.post(f'{self.url}/incidents', params=params, headers=self.headers)
+
+@click.group()
+def run_client():
+    pass
+
+@click.command()
+@click.argument('url')
+@click.argument('token')
+@click.argument('output')
+def run_client(url, token, output):
+    client = CachetClient(url, token)
+    config = client.generate_config()
+    save_config(config, output)
+
+if __name__ == '__main__':
+    run_client()

cachet_url_monitor/configuration.py

@@ -1,82 +1,57 @@
 #!/usr/bin/env python
-import abc
 import copy
 import logging
-import os
-import re
 import time
+from typing import Dict
 
 import requests
 from yaml import dump
 
-import cachet_url_monitor.latency_unit as latency_unit
 import cachet_url_monitor.status as st
+from cachet_url_monitor.client import CachetClient, normalize_url
+from cachet_url_monitor.exceptions import ConfigurationValidationError
+from cachet_url_monitor.expectation import Expectation
+from cachet_url_monitor.status import ComponentStatus
 
 # This is the mandatory fields that must be in the configuration file in this
 # same exact structure.
 configuration_mandatory_fields = ['url', 'method', 'timeout', 'expectation', 'component_id', 'frequency']
 
 
-class ConfigurationValidationError(Exception):
-    """Exception raised when there's a validation error."""
-
-    def __init__(self, value):
-        self.value = value
-
-    def __str__(self):
-        return repr(self.value)
-
-
-class ComponentNonexistentError(Exception):
-    """Exception raised when the component does not exist."""
-
-    def __init__(self, component_id):
-        self.component_id = component_id
-
-    def __str__(self):
-        return repr(f'Component with id [{self.component_id}] does not exist.')
-
-
-class MetricNonexistentError(Exception):
-    """Exception raised when the component does not exist."""
-
-    def __init__(self, metric_id):
-        self.metric_id = metric_id
-
-    def __str__(self):
-        return repr(f'Metric with id [{self.metric_id}] does not exist.')
-
-
-def get_current_status(endpoint_url, component_id, headers):
-    """Retrieves the current status of the component that is being monitored. It will fail if the component does
-    not exist or doesn't respond with the expected data.
-    :return component status.
-    """
-    get_status_request = requests.get(f'{endpoint_url}/components/{component_id}', headers=headers)
-
-    if get_status_request.ok:
-        # The component exists.
-        return int(get_status_request.json()['data']['status'])
-    else:
-        raise ComponentNonexistentError(component_id)
-
-
-def normalize_url(url):
-    """If passed url doesn't include schema return it with default one - http."""
-    if not url.lower().startswith('http'):
-        return f'http://{url}'
-    return url
-
-
 class Configuration(object):
     """Represents a configuration file, but it also includes the functionality
     of assessing the API and pushing the results to cachet.
     """
+    endpoint_index: int
+    endpoint: str
+    client: CachetClient
+    token: str
+    current_fails: int
+    trigger_update: bool
+    headers: Dict[str, str]
 
-    def __init__(self, config_file, endpoint_index):
+    endpoint_method: str
+    endpoint_url: str
+    endpoint_timeout: int
+    endpoint_header: Dict[str, str]
+
+    allowed_fails: int
+    component_id: int
+    metric_id: int
+    default_metric_value: int
+    latency_unit: str
+
+    status: ComponentStatus
+    previous_status: ComponentStatus
+    message: str
+
+    def __init__(self, config, endpoint_index: int, client: CachetClient, token: str):
         self.endpoint_index = endpoint_index
-        self.data = config_file
+        self.data = config
         self.endpoint = self.data['endpoints'][endpoint_index]
+        self.client = client
+        self.token = token
+
         self.current_fails = 0
         self.trigger_update = True
 
@@ -93,28 +68,28 @@ class Configuration(object):
         self.validate()
 
         # We store the main information from the configuration file, so we don't keep reading from the data dictionary.
-        self.headers = {'X-Cachet-Token': os.environ.get('CACHET_TOKEN') or self.data['cachet']['token']}
+
+        self.headers = {'X-Cachet-Token': self.token}
 
         self.endpoint_method = self.endpoint['method']
-        self.endpoint_url = self.endpoint['url']
+        self.endpoint_url = normalize_url(self.endpoint['url'])
-        self.endpoint_url = normalize_url(self.endpoint_url)
         self.endpoint_timeout = self.endpoint.get('timeout') or 1
         self.endpoint_header = self.endpoint.get('header') or None
         self.allowed_fails = self.endpoint.get('allowed_fails') or 0
 
-        self.api_url = os.environ.get('CACHET_API_URL') or self.data['cachet']['api_url']
         self.component_id = self.endpoint['component_id']
         self.metric_id = self.endpoint.get('metric_id')
 
         if self.metric_id is not None:
-            self.default_metric_value = self.get_default_metric_value(self.metric_id)
+            self.default_metric_value = self.client.get_default_metric_value(self.metric_id)
 
         # The latency_unit configuration is not mandatory and we fallback to seconds, by default.
         self.latency_unit = self.data['cachet'].get('latency_unit') or 's'
 
         # We need the current status so we monitor the status changes. This is necessary for creating incidents.
-        self.status = get_current_status(self.api_url, self.component_id, self.headers)
+        self.status = self.client.get_component_status(self.component_id)
         self.previous_status = self.status
+        self.logger.info(f'Component current status: {self.status}')
 
         # Get remaining settings
         self.public_incidents = int(self.endpoint['public_incidents'])
@@ -124,15 +99,6 @@ class Configuration(object):
         for expectation in self.expectations:
             self.logger.info('Registered expectation: %s' % (expectation,))
 
-    def get_default_metric_value(self, metric_id):
-        """Returns default value for configured metric."""
-        get_metric_request = requests.get('%s/metrics/%s' % (self.api_url, metric_id), headers=self.headers)
-
-        if get_metric_request.ok:
-            return get_metric_request.json()['data']['default_value']
-        else:
-            raise MetricNonexistentError(metric_id)
-
     def get_action(self):
         """Retrieves the action list from the configuration. If it's empty, returns an empty list.
         :return: The list of actions, which can be an empty list.
@@ -178,27 +144,27 @@ class Configuration(object):
         except requests.ConnectionError:
             self.message = 'The URL is unreachable: %s %s' % (self.endpoint_method, self.endpoint_url)
             self.logger.warning(self.message)
-            self.status = st.COMPONENT_STATUS_PARTIAL_OUTAGE
+            self.status = st.ComponentStatus.PARTIAL_OUTAGE
             return
         except requests.HTTPError:
             self.message = 'Unexpected HTTP response'
             self.logger.exception(self.message)
-            self.status = st.COMPONENT_STATUS_PARTIAL_OUTAGE
+            self.status = st.ComponentStatus.PARTIAL_OUTAGE
             return
-        except requests.Timeout:
+        except (requests.Timeout, requests.ConnectTimeout):
             self.message = 'Request timed out'
             self.logger.warning(self.message)
-            self.status = st.COMPONENT_STATUS_PERFORMANCE_ISSUES
+            self.status = st.ComponentStatus.PERFORMANCE_ISSUES
             return
 
         # We initially assume the API is healthy.
-        self.status = st.COMPONENT_STATUS_OPERATIONAL
+        self.status = st.ComponentStatus.OPERATIONAL
         self.message = ''
         for expectation in self.expectations:
-            status = expectation.get_status(self.request)
+            status: ComponentStatus = expectation.get_status(self.request)
 
             # The greater the status is, the worse the state of the API is.
-            if status > self.status:
+            if status.value > self.status.value:
                 self.status = status
                 self.message = expectation.get_message(self.request)
                 self.logger.info(self.message)
@@ -220,7 +186,7 @@ class Configuration(object):
         and only for non-operational ones above the configured threshold (allowed_fails).
         """
 
-        if self.status != 1:
+        if self.status != st.ComponentStatus.OPERATIONAL:
             self.current_fails = self.current_fails + 1
             self.logger.warning(f'Failure #{self.current_fails} with threshold set to {self.allowed_fails}')
             if self.current_fails <= self.allowed_fails:
@@ -234,27 +200,29 @@ class Configuration(object):
         status based on the previous call to evaluate().
         """
         if self.previous_status == self.status:
+            # We don't want to keep spamming if there's no change in status.
+            self.logger.info(f'No changes to component status.')
+            self.trigger_update = False
             return
+
         self.previous_status = self.status
 
         if not self.trigger_update:
             return
 
-        self.api_component_status = get_current_status(self.api_url, self.component_id, self.headers)
+        api_component_status = self.client.get_component_status(self.component_id)
 
-        if self.status == self.api_component_status:
+        if self.status == api_component_status:
             return
 
-        params = {'id': self.component_id, 'status': self.status}
+        component_request = self.client.push_status(self.component_id, self.status)
-        component_request = requests.put('%s/components/%d' % (self.api_url, self.component_id), params=params,
-                                         headers=self.headers)
         if component_request.ok:
             # Successful update
-            self.logger.info('Component update: status [%d]' % (self.status,))
+            self.logger.info(f'Component update: status [{self.status}]')
         else:
             # Failed to update the API status
-            self.logger.warning('Component update failed with status [%d]: API'
+            self.logger.warning(f'Component update failed with HTTP status: {component_request.status_code}. API'
-                                ' status: [%d]' % (component_request.status_code, self.status))
+                                f' status: {self.status}')
 
     def push_metrics(self):
         """Pushes the total amount of seconds the request took to get a response from the URL.
@@ -263,16 +231,11 @@ class Configuration(object):
         """
         if 'metric_id' in self.data['cachet'] and hasattr(self, 'request'):
             # We convert the elapsed time from the request, in seconds, to the configured unit.
-            value = self.default_metric_value if self.status != 1 else latency_unit.convert_to_unit(self.latency_unit,
+            metrics_request = self.client.push_metrics(self.metric_id, self.latency_unit,
-                                                                                                    self.request.elapsed.total_seconds())
+                                                       self.request.elapsed.total_seconds(), self.current_timestamp)
-            params = {'id': self.metric_id, 'value': value,
-                      'timestamp': self.current_timestamp}
-            metrics_request = requests.post('%s/metrics/%d/points' % (self.api_url, self.metric_id), params=params,
-                                            headers=self.headers)
-
             if metrics_request.ok:
                 # Successful metrics upload
-                self.logger.info('Metric uploaded: %.6f %s' % (value, self.latency_unit))
+                self.logger.info('Metric uploaded: %.6f %s' % (self.request.elapsed.total_seconds(), self.latency_unit))
             else:
                 self.logger.warning(f'Metric upload failed with status [{metrics_request.status_code}]')
 
@@ -282,14 +245,10 @@ class Configuration(object):
         """
         if not self.trigger_update:
             return
-        if hasattr(self, 'incident_id') and self.status == st.COMPONENT_STATUS_OPERATIONAL:
+        if hasattr(self, 'incident_id') and self.status == st.ComponentStatus.OPERATIONAL:
-            # If the incident already exists, it means it was unhealthy but now it's healthy again.
+            incident_request = self.client.push_incident(self.status, self.public_incidents, self.component_id,
-            params = {'status': 4, 'visible': self.public_incidents, 'component_id': self.component_id,
+                                                         previous_incident_id=self.incident_id)
-                      'component_status': self.status,
-                      'notify': True}
 
-            incident_request = requests.put(f'{self.api_url}/incidents/{self.incident_id}', params=params,
-                                            headers=self.headers)
             if incident_request.ok:
                 # Successful metrics upload
                 self.logger.info(
@@ -298,11 +257,9 @@ class Configuration(object):
             else:
                 self.logger.warning(
                     f'Incident update failed with status [{incident_request.status_code}], message: "{self.message}"')
-        elif not hasattr(self, 'incident_id') and self.status != st.COMPONENT_STATUS_OPERATIONAL:
+        elif not hasattr(self, 'incident_id') and self.status != st.ComponentStatus.OPERATIONAL:
-            # This is the first time the incident is being created.
+            incident_request = self.client.push_incident(self.status, self.public_incidents, self.component_id,
-            params = {'name': 'URL unavailable', 'message': self.message, 'status': 1, 'visible': self.public_incidents,
+                                                         message=self.message)
-                      'component_id': self.component_id, 'component_status': self.status, 'notify': True}
-            incident_request = requests.post(f'{self.api_url}/incidents', params=params, headers=self.headers)
             if incident_request.ok:
                 # Successful incident upload.
                 self.incident_id = incident_request.json()['data']['id']
@@ -311,120 +268,3 @@ class Configuration(object):
             else:
                 self.logger.warning(
                     f'Incident upload failed with status [{incident_request.status_code}], message: "{self.message}"')
-
-
-class Expectation(object):
-    """Base class for URL result expectations. Any new expectation should extend
-    this class and the name added to create() method.
-    """
-
-    @staticmethod
-    def create(configuration):
-        """Creates a list of expectations based on the configuration types
-        list.
-        """
-        # If a need expectation is created, this is where we need to add it.
-        expectations = {
-            'HTTP_STATUS': HttpStatus,
-            'LATENCY': Latency,
-            'REGEX': Regex
-        }
-        return expectations.get(configuration['type'])(configuration)
-
-    def __init__(self, configuration):
-        self.incident_status = self.parse_incident_status(configuration)
-
-    @abc.abstractmethod
-    def get_status(self, response):
-        """Returns the status of the API, following cachet's component status
-        documentation: https://docs.cachethq.io/docs/component-statuses
-        """
-
-    @abc.abstractmethod
-    def get_message(self, response):
-        """Gets the error message."""
-
-    @abc.abstractmethod
-    def get_default_incident(self):
-        """Returns the default status when this incident happens."""
-
-    def parse_incident_status(self, configuration):
-        return st.INCIDENT_MAP.get(configuration.get('incident', None), self.get_default_incident())
-
-
-class HttpStatus(Expectation):
-    def __init__(self, configuration):
-        self.status_range = HttpStatus.parse_range(configuration['status_range'])
-        super(HttpStatus, self).__init__(configuration)
-
-    @staticmethod
-    def parse_range(range_string):
-        if isinstance(range_string, int):
-            # This happens when there's no range and no dash character, it will be parsed as int already.
-            return range_string, range_string + 1
-
-        statuses = range_string.split("-")
-        if len(statuses) == 1:
-            # When there was no range given, we should treat the first number as a single status check.
-            return int(statuses[0]), int(statuses[0]) + 1
-        else:
-            # We shouldn't look into more than one value, as this is a range value.
-            return int(statuses[0]), int(statuses[1])
-
-    def get_status(self, response):
-        if self.status_range[0] <= response.status_code < self.status_range[1]:
-            return st.COMPONENT_STATUS_OPERATIONAL
-        else:
-            return self.incident_status
-
-    def get_default_incident(self):
-        return st.COMPONENT_STATUS_PARTIAL_OUTAGE
-
-    def get_message(self, response):
-        return f'Unexpected HTTP status ({response.status_code})'
-
-    def __str__(self):
-        return repr(f'HTTP status range: [{self.status_range[0]}, {self.status_range[1]}[')
-
-
-class Latency(Expectation):
-    def __init__(self, configuration):
-        self.threshold = configuration['threshold']
-        super(Latency, self).__init__(configuration)
-
-    def get_status(self, response):
-        if response.elapsed.total_seconds() <= self.threshold:
-            return st.COMPONENT_STATUS_OPERATIONAL
-        else:
-            return self.incident_status
-
-    def get_default_incident(self):
-        return st.COMPONENT_STATUS_PERFORMANCE_ISSUES
-
-    def get_message(self, response):
-        return 'Latency above threshold: %.4f seconds' % (response.elapsed.total_seconds(),)
-
-    def __str__(self):
-        return repr('Latency threshold: %.4f seconds' % (self.threshold,))
-
-
-class Regex(Expectation):
-    def __init__(self, configuration):
-        self.regex_string = configuration['regex']
-        self.regex = re.compile(configuration['regex'], re.UNICODE + re.DOTALL)
-        super(Regex, self).__init__(configuration)
-
-    def get_status(self, response):
-        if self.regex.match(response.text):
-            return st.COMPONENT_STATUS_OPERATIONAL
-        else:
-            return self.incident_status
-
-    def get_default_incident(self):
-        return st.COMPONENT_STATUS_PARTIAL_OUTAGE
-
-    def get_message(self, response):
-        return 'Regex did not match anything in the body'
-
-    def __str__(self):
-        return repr(f'Regex: {self.regex_string}')

cachet_url_monitor/exceptions.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+class ComponentNonexistentError(Exception):
+    """Exception raised when the component does not exist."""
+
+    def __init__(self, component_id):
+        self.component_id = component_id
+
+    def __str__(self):
+        return repr(f'Component with id [{self.component_id}] does not exist.')
+
+
+class MetricNonexistentError(Exception):
+    """Exception raised when the component does not exist."""
+
+    def __init__(self, metric_id):
+        self.metric_id = metric_id
+
+    def __str__(self):
+        return repr(f'Metric with id [{self.metric_id}] does not exist.')
+
+
+class ConfigurationValidationError(Exception):
+    """Exception raised when there's a validation error."""
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return repr(self.value)

cachet_url_monitor/expectation.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+import abc
+import re
+
+import cachet_url_monitor.status as st
+from cachet_url_monitor.exceptions import ConfigurationValidationError
+from cachet_url_monitor.status import ComponentStatus
+
+
+class Expectation(object):
+    """Base class for URL result expectations. Any new expectation should extend
+    this class and the name added to create() method.
+    """
+
+    @staticmethod
+    def create(configuration):
+        """Creates a list of expectations based on the configuration types
+        list.
+        """
+        # If a need expectation is created, this is where we need to add it.
+        expectations = {
+            'HTTP_STATUS': HttpStatus,
+            'LATENCY': Latency,
+            'REGEX': Regex
+        }
+        if configuration['type'] not in expectations:
+            raise ConfigurationValidationError(f"Invalid type: {configuration['type']}")
+
+        return expectations.get(configuration['type'])(configuration)
+
+    def __init__(self, configuration):
+        self.incident_status = self.parse_incident_status(configuration)
+
+    @abc.abstractmethod
+    def get_status(self, response) -> ComponentStatus:
+        """Returns the status of the API, following cachet's component status
+        documentation: https://docs.cachethq.io/docs/component-statuses
+        """
+
+    @abc.abstractmethod
+    def get_message(self, response) -> str:
+        """Gets the error message."""
+
+    @abc.abstractmethod
+    def get_default_incident(self):
+        """Returns the default status when this incident happens."""
+
+    def parse_incident_status(self, configuration) -> ComponentStatus:
+        return st.INCIDENT_MAP.get(configuration.get('incident', None), self.get_default_incident())
+
+
+class HttpStatus(Expectation):
+    def __init__(self, configuration):
+        self.status_range = HttpStatus.parse_range(configuration['status_range'])
+        super(HttpStatus, self).__init__(configuration)
+
+    @staticmethod
+    def parse_range(range_string):
+        if isinstance(range_string, int):
+            # This happens when there's no range and no dash character, it will be parsed as int already.
+            return range_string, range_string + 1
+
+        statuses = range_string.split("-")
+        if len(statuses) == 1:
+            # When there was no range given, we should treat the first number as a single status check.
+            return int(statuses[0]), int(statuses[0]) + 1
+        else:
+            # We shouldn't look into more than one value, as this is a range value.
+            return int(statuses[0]), int(statuses[1])
+
+    def get_status(self, response) -> ComponentStatus:
+        if self.status_range[0] <= response.status_code < self.status_range[1]:
+            return st.ComponentStatus.OPERATIONAL
+        else:
+            return self.incident_status
+
+    def get_default_incident(self):
+        return st.ComponentStatus.PARTIAL_OUTAGE
+
+    def get_message(self, response):
+        return f'Unexpected HTTP status ({response.status_code})'
+
+    def __str__(self):
+        return repr(f'HTTP status range: [{self.status_range[0]}, {self.status_range[1]}[')
+
+
+class Latency(Expectation):
+    def __init__(self, configuration):
+        self.threshold = configuration['threshold']
+        super(Latency, self).__init__(configuration)
+
+    def get_status(self, response) -> ComponentStatus:
+        if response.elapsed.total_seconds() <= self.threshold:
+            return st.ComponentStatus.OPERATIONAL
+        else:
+            return self.incident_status
+
+    def get_default_incident(self):
+        return st.ComponentStatus.PERFORMANCE_ISSUES
+
+    def get_message(self, response):
+        return 'Latency above threshold: %.4f seconds' % (response.elapsed.total_seconds(),)
+
+    def __str__(self):
+        return repr('Latency threshold: %.4f seconds' % (self.threshold,))
+
+
+class Regex(Expectation):
+    def __init__(self, configuration):
+        self.regex_string = configuration['regex']
+        self.regex = re.compile(configuration['regex'], re.UNICODE + re.DOTALL)
+        super(Regex, self).__init__(configuration)
+
+    def get_status(self, response) -> ComponentStatus:
+        if self.regex.match(response.text):
+            return st.ComponentStatus.OPERATIONAL
+        else:
+            return self.incident_status
+
+    def get_default_incident(self):
+        return st.ComponentStatus.PARTIAL_OUTAGE
+
+    def get_message(self, response):
+        return 'Regex did not match anything in the body'
+
+    def __str__(self):
+        return repr(f'Regex: {self.regex_string}')

cachet_url_monitor/latency_unit.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python
+from typing import Dict
 
-seconds_per_unit = {"ms": 1000, "milliseconds": 1000, "s": 1, "seconds": 1, "m": float(1) / 60,
+seconds_per_unit: Dict[str, float] = {"ms": 1000, "milliseconds": 1000, "s": 1, "seconds": 1, "m": float(1) / 60,
                     "minutes": float(1) / 60, "h": float(1) / 3600, "hours": float(1) / 3600}
 
 
-def convert_to_unit(time_unit, value):
+def convert_to_unit(time_unit: str, value: float):
     """
     Will convert the given value from seconds to the given time_unit.
 

cachet_url_monitor/scheduler.py

@@ -3,10 +3,12 @@ import logging
 import sys
 import threading
 import time
+import os
 
 import schedule
 from yaml import load, SafeLoader
 
+from cachet_url_monitor.client import CachetClient
 from cachet_url_monitor.configuration import Configuration
 
 cachet_mandatory_fields = ['api_url', 'token']
@@ -40,45 +42,40 @@ class Agent(object):
 
 
 class Decorator(object):
+    """Defines the actions a user can configure to be executed when there's an incident."""
+
     def execute(self, configuration):
         pass
 
 
 class UpdateStatusDecorator(Decorator):
+    """Updates the component status when an incident happens."""
+
     def execute(self, configuration):
         configuration.push_status()
 
 
 class CreateIncidentDecorator(Decorator):
+    """Creates an incident entry on cachet when an incident happens."""
+
     def execute(self, configuration):
         configuration.push_incident()
 
 
 class PushMetricsDecorator(Decorator):
+    """Updates the URL latency metric."""
+
     def execute(self, configuration):
         configuration.push_metrics()
 
 
 class Scheduler(object):
-    def __init__(self, config_file, endpoint_index):
+    def __init__(self, configuration, agent):
         self.logger = logging.getLogger('cachet_url_monitor.scheduler.Scheduler')
-        self.configuration = Configuration(config_file, endpoint_index)
+        self.configuration = configuration
-        self.agent = self.get_agent()
+        self.agent = agent
-
         self.stop = False
 
-    def get_agent(self):
-        action_names = {
-            'CREATE_INCIDENT': CreateIncidentDecorator,
-            'UPDATE_STATUS': UpdateStatusDecorator,
-            'PUSH_METRICS': PushMetricsDecorator,
-        }
-        actions = []
-        for action in self.configuration.get_action():
-            self.logger.info(f'Registering action {action}')
-            actions.append(action_names[action]())
-        return Agent(self.configuration, decorators=actions)
-
     def start(self):
         self.agent.start()
         self.logger.info('Starting monitor agent...')
@@ -96,15 +93,28 @@ class NewThread(threading.Thread):
         self.scheduler.start()
 
 
+def build_agent(configuration, logger):
+    action_names = {
+        'CREATE_INCIDENT': CreateIncidentDecorator,
+        'UPDATE_STATUS': UpdateStatusDecorator,
+        'PUSH_METRICS': PushMetricsDecorator,
+    }
+    actions = []
+    for action in configuration.get_action():
+        logger.info(f'Registering action {action}')
+        actions.append(action_names[action]())
+    return Agent(configuration, decorators=actions)
+
+
 def validate_config():
-    if 'endpoints' not in config_file.keys():
+    if 'endpoints' not in config_data.keys():
         fatal_error('Endpoints is a mandatory field')
 
-    if config_file['endpoints'] is None:
+    if config_data['endpoints'] is None:
         fatal_error('Endpoints array can not be empty')
 
     for key in cachet_mandatory_fields:
-        if key not in config_file['cachet']:
+        if key not in config_data['cachet']:
             fatal_error('Missing cachet mandatory fields')
 
 
@@ -124,12 +134,16 @@ if __name__ == "__main__":
         sys.exit(1)
 
     try:
-        config_file = load(open(sys.argv[1], 'r'), SafeLoader)
+        config_data = load(open(sys.argv[1], 'r'), SafeLoader)
     except FileNotFoundError:
         logging.getLogger('cachet_url_monitor.scheduler').fatal(f'File not found: {sys.argv[1]}')
         sys.exit(1)
 
     validate_config()
 
-    for endpoint_index in range(len(config_file['endpoints'])):
+    for endpoint_index in range(len(config_data['endpoints'])):
-        NewThread(Scheduler(config_file, endpoint_index)).start()
+        token = os.environ.get('CACHET_TOKEN') or config_data['cachet']['token']
+        api_url = os.environ.get('CACHET_API_URL') or config_data['cachet']['api_url']
+        configuration = Configuration(config_data, endpoint_index, CachetClient(api_url, token), token)
+        NewThread(Scheduler(configuration,
+                            build_agent(configuration, logging.getLogger('cachet_url_monitor.scheduler')))).start()

cachet_url_monitor/status.py

@@ -3,22 +3,31 @@
 This file defines all the different status different values.
 These are all constants and are coupled to cachet's API configuration.
 """
+from enum import Enum
 
-COMPONENT_STATUS_OPERATIONAL = 1
-COMPONENT_STATUS_PERFORMANCE_ISSUES = 2
-COMPONENT_STATUS_PARTIAL_OUTAGE = 3
-COMPONENT_STATUS_MAJOR_OUTAGE = 4
 
-COMPONENT_STATUSES = [COMPONENT_STATUS_OPERATIONAL,
+class ComponentStatus(Enum):
-                      COMPONENT_STATUS_PERFORMANCE_ISSUES, COMPONENT_STATUS_PARTIAL_OUTAGE,
+    UNKNOWN = 0
-                      COMPONENT_STATUS_MAJOR_OUTAGE]
+    OPERATIONAL = 1
+    PERFORMANCE_ISSUES = 2
+    PARTIAL_OUTAGE = 3
+    MAJOR_OUTAGE = 4
+
 
 INCIDENT_PARTIAL = 'PARTIAL'
 INCIDENT_MAJOR = 'MAJOR'
 INCIDENT_PERFORMANCE = 'PERFORMANCE'
 
 INCIDENT_MAP = {
-    INCIDENT_PARTIAL: COMPONENT_STATUS_PARTIAL_OUTAGE,
+    INCIDENT_PARTIAL: ComponentStatus.PARTIAL_OUTAGE,
-    INCIDENT_MAJOR: COMPONENT_STATUS_MAJOR_OUTAGE,
+    INCIDENT_MAJOR: ComponentStatus.MAJOR_OUTAGE,
-    INCIDENT_PERFORMANCE: COMPONENT_STATUS_PERFORMANCE_ISSUES,
+    INCIDENT_PERFORMANCE: ComponentStatus.PERFORMANCE_ISSUES,
 }
+
+
+class IncidentStatus(Enum):
+    SCHEDULED = 0
+    INVESTIGATING = 1
+    IDENTIFIED = 2
+    WATCHING = 3
+    FIXED = 4

dev_requirements.txt

@@ -1,7 +1,10 @@
 codacy-coverage==1.3.11
-ipython==7.8.0
+coverage==5.0.3
-mock==2.0.0
+coveralls==1.10.0
-pudb==2016.1
+ipython==7.11.1
-pytest==5.2.2
+mock==3.0.5
+pudb==2019.2
+pytest==5.3.5
 pytest-cov==2.8.1
-coverage==4.5.2
+requests-mock==1.7.0
+twine==3.1.1

requirements.txt

@@ -1,3 +1,4 @@
-PyYAML==5.1.2
+PyYAML==5.3
 requests==2.22.0
 schedule==0.6.0
+Click==7.0

setup.py

@@ -1,20 +1,21 @@
 #!/usr/bin/env python
 #from distutils.core import setup
-from setuptools import setup
+from setuptools import setup, find_packages
 
 setup(name='cachet-url-monitor',
-      version='0.6.0',
+      version='0.6.7',
       description='Cachet URL monitor plugin',
       author='Mitsuo Takaki',
       author_email='mitsuotakaki@gmail.com',
       url='https://github.com/mtakaki/cachet-url-monitor',
-      packages=['cachet_url_monitor'],
+      packages=find_packages(),
       license='MIT',
       requires=[
           'requests',
           'yaml',
           'schedule',
+          'Click',
       ],
       setup_requires=["pytest-runner"],
-      tests_require=["pytest"]
+      tests_require=["pytest", "requests-mock"]
       )

tests/configs/config.yml

@@ -0,0 +1,26 @@
+endpoints:
+  - name: foo
+    url: http://localhost:8080/swagger
+    method: GET
+    header:
+      SOME-HEADER: SOME-VALUE
+    timeout: 0.01
+    expectation:
+      - type: HTTP_STATUS
+        status_range: 200-300
+        incident: MAJOR
+      - type: LATENCY
+        threshold: 1
+      - type: REGEX
+        regex: '.*(<body).*'
+    allowed_fails: 0
+    component_id: 1
+    action:
+      - CREATE_INCIDENT
+      - UPDATE_STATUS
+    public_incidents: true
+    latency_unit: ms
+    frequency: 30
+cachet:
+  api_url: https://demo.cachethq.io/api/v1
+  token: my_token

tests/configs/config_invalid_type.yml

@@ -0,0 +1,22 @@
+endpoints:
+  - name: foo
+    url: http://localhost:8080/swagger
+    method: GET
+    header:
+      SOME-HEADER: SOME-VALUE
+    timeout: 0.01
+    expectation:
+      - type: HTTP
+        status_range: 200-300
+        incident: MAJOR
+    allowed_fails: 0
+    component_id: 1
+    action:
+      - CREATE_INCIDENT
+      - UPDATE_STATUS
+    public_incidents: true
+    latency_unit: ms
+    frequency: 30
+cachet:
+  api_url: https://demo.cachethq.io/api/v1
+  token: my_token

tests/configs/config_multiple_urls.yml

@@ -0,0 +1,28 @@
+endpoints:
+  - name: foo
+    url: http://localhost:8080/swagger
+    method: GET
+    expectation:
+      - type: HTTP_STATUS
+        status_range: 200-300
+    allowed_fails: 0
+    component_id: 1
+    latency_unit: ms
+    frequency: 30
+    timeout: 1
+    public_incidents: true
+  - name: bar
+    url: http://localhost:8080/bar
+    method: POST
+    expectation:
+      - type: HTTP_STATUS
+        status_range: 500
+    allowed_fails: 0
+    component_id: 2
+    latency_unit: ms
+    frequency: 30
+    timeout: 1
+    public_incidents: true
+cachet:
+  api_url: https://demo.cachethq.io/api/v1
+  token: my_token

tests/test_client.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python
+import unittest
+from typing import Dict, List
+
+import requests_mock
+
+from cachet_url_monitor.client import CachetClient
+from cachet_url_monitor.exceptions import MetricNonexistentError
+from cachet_url_monitor.status import ComponentStatus
+
+TOKEN: str = 'token_123'
+CACHET_URL: str = 'http://foo.localhost'
+JSON: Dict[str, List[Dict[str, int]]] = {'data': [{'id': 1}]}
+
+
+class ClientTest(unittest.TestCase):
+    def setUp(self):
+        self.client = CachetClient('foo.localhost', TOKEN)
+
+    def test_init(self):
+        self.assertEqual(self.client.headers, {'X-Cachet-Token': TOKEN}, 'Header was not set correctly')
+        self.assertEqual(self.client.url, CACHET_URL, 'Cachet API URL was set incorrectly')
+
+    @requests_mock.mock()
+    def test_get_components(self, m):
+        m.get(f'{CACHET_URL}/components', json=JSON, headers={'X-Cachet-Token': TOKEN})
+        components = self.client.get_components()
+
+        self.assertEqual(components, [{'id': 1}],
+                         'Getting components list is incorrect.')
+
+    @requests_mock.mock()
+    def test_get_metrics(self, m):
+        m.get(f'{CACHET_URL}/metrics', json=JSON)
+        metrics = self.client.get_metrics()
+
+        self.assertEqual(metrics, [{'id': 1}],
+                         'Getting metrics list is incorrect.')
+
+    @requests_mock.mock()
+    def test_generate_config(self, m):
+        def components():
+            return {
+                'data': [
+                    {
+                        'id': '1',
+                        'name': 'apache',
+                        'link': 'http://abc.def',
+                        'enabled': True
+                    },
+                    {
+                        'id': '2',
+                        'name': 'haproxy',
+                        'link': 'http://ghi.jkl',
+                        'enabled': False
+                    },
+                    {
+                        'id': '3',
+                        'name': 'nginx',
+                        'link': 'http://mno.pqr',
+                        'enabled': True
+                    }
+                ]
+            }
+
+        m.get(f'{CACHET_URL}/components', json=components(), headers={'X-Cachet-Token': TOKEN})
+        config = self.client.generate_config()
+
+        self.assertEqual(config, {
+            'cachet': {
+                'api_url': CACHET_URL,
+                'token': TOKEN
+            },
+            'endpoints': [
+                {
+                    'name': 'apache',
+                    'url': 'http://abc.def',
+                    'method': 'GET',
+                    'timeout': 1,
+                    'expectation': [
+                        {
+                            'type': 'HTTP_STATUS',
+                            'status_range': '200-300',
+                            'incident': 'MAJOR'
+                        }
+                    ],
+                    'allowed_fails': 0,
+                    'frequency': 30,
+                    'component_id': '1',
+                    'action': [
+                        'CREATE_INCIDENT',
+                        'UPDATE_STATUS',
+                    ],
+                    'public_incidents': True,
+                },
+                {
+                    'name': 'nginx',
+                    'url': 'http://mno.pqr',
+                    'method': 'GET',
+                    'timeout': 1,
+                    'expectation': [
+                        {
+                            'type': 'HTTP_STATUS',
+                            'status_range': '200-300',
+                            'incident': 'MAJOR'
+                        }
+                    ],
+                    'allowed_fails': 0,
+                    'frequency': 30,
+                    'component_id': '3',
+                    'action': [
+                        'CREATE_INCIDENT',
+                        'UPDATE_STATUS',
+                    ],
+                    'public_incidents': True,
+                }
+            ]
+        }, 'Generated config is incorrect.')
+
+    @requests_mock.mock()
+    def test_get_default_metric_value(self, m):
+        m.get(f'{CACHET_URL}/metrics/123', json={'data': {'default_value': 0.456}}, headers={'X-Cachet-Token': TOKEN})
+        default_metric_value = self.client.get_default_metric_value(123)
+
+        self.assertEqual(default_metric_value, 0.456,
+                         'Getting default metric value is incorrect.')
+
+    @requests_mock.mock()
+    def test_get_default_metric_value_invalid_id(self, m):
+        m.get(f'{CACHET_URL}/metrics/123', headers={'X-Cachet-Token': TOKEN}, status_code=400)
+        with self.assertRaises(MetricNonexistentError):
+            self.client.get_default_metric_value(123)
+
+    @requests_mock.mock()
+    def test_get_component_status(self, m):
+        def json():
+            return {
+                'data': {
+                    'status': ComponentStatus.OPERATIONAL.value
+                }
+            }
+
+        m.get(f'{CACHET_URL}/components/123', json=json(), headers={'X-Cachet-Token': TOKEN})
+        status = self.client.get_component_status(123)
+
+        self.assertEqual(status, ComponentStatus.OPERATIONAL,
+                         'Getting component status value is incorrect.')
+
+    @requests_mock.mock()
+    def test_push_status(self, m):
+        m.put(f'{CACHET_URL}/components/123?id=123&status={ComponentStatus.PARTIAL_OUTAGE.value}',
+              headers={'X-Cachet-Token': TOKEN})
+        response = self.client.push_status(123, ComponentStatus.PARTIAL_OUTAGE)
+
+        self.assertTrue(response.ok, 'Pushing status value is failed.')

tests/test_configuration.py

@@ -1,176 +1,184 @@
 #!/usr/bin/env python
 import sys
-import unittest
 
 import mock
-from requests import ConnectionError, HTTPError, Timeout
+import pytest
+import requests
+import requests_mock
 from yaml import load, SafeLoader
 
+import cachet_url_monitor.exceptions
 import cachet_url_monitor.status
 
-sys.modules['requests'] = mock.Mock()
 sys.modules['logging'] = mock.Mock()
 from cachet_url_monitor.configuration import Configuration
 import os
 
 
-class ConfigurationTest(unittest.TestCase):
+@pytest.fixture()
-    @mock.patch.dict(os.environ, {'CACHET_TOKEN': 'token2'})
+def mock_client():
-    def setUp(self):
+    client = mock.Mock()
+    client.get_component_status.return_value = cachet_url_monitor.status.ComponentStatus.OPERATIONAL
+    yield client
+
+
+@pytest.fixture()
+def config_file():
+    with open(os.path.join(os.path.dirname(__file__), 'configs/config.yml'), 'rt') as yaml_file:
+        config_file_data = load(yaml_file, SafeLoader)
+        yield config_file_data
+
+
+@pytest.fixture()
+def multiple_urls_config_file():
+    with open(os.path.join(os.path.dirname(__file__), 'configs/config_multiple_urls.yml'), 'rt') as yaml_file:
+        config_file_data = load(yaml_file, SafeLoader)
+        yield config_file_data
+
+
+@pytest.fixture()
+def invalid_config_file():
+    with open(os.path.join(os.path.dirname(__file__), 'configs/config_invalid_type.yml'), 'rt') as yaml_file:
+        config_file_data = load(yaml_file, SafeLoader)
+        yield config_file_data
+
+
+@pytest.fixture()
+def mock_logger():
+    mock_logger = mock.Mock()
+
     def getLogger(name):
-            self.mock_logger = mock.Mock()
+        return mock_logger
-            return self.mock_logger
 
     sys.modules['logging'].getLogger = getLogger
+    yield mock_logger
 
-        def get(url, headers):
-            get_return = mock.Mock()
-            get_return.ok = True
-            get_return.json = mock.Mock()
-            get_return.json.return_value = {'data': {'status': 1, 'default_value': 0.5}}
-            return get_return
 
-        sys.modules['requests'].get = get
+@pytest.fixture()
+def configuration(config_file, mock_client, mock_logger):
+    yield Configuration(config_file, 0, mock_client, 'token2')
 
-        self.configuration = Configuration(load(open('config.yml', 'r'), SafeLoader), 0)
-        sys.modules['requests'].Timeout = Timeout
-        sys.modules['requests'].ConnectionError = ConnectionError
-        sys.modules['requests'].HTTPError = HTTPError
 
-    def test_init(self):
+@pytest.fixture()
-        self.assertEqual(len(self.configuration.data), 2, 'Number of root elements in config.yml is incorrect')
+def multiple_urls_configuration(multiple_urls_config_file, mock_client, mock_logger):
-        self.assertEqual(len(self.configuration.expectations), 3, 'Number of expectations read from file is incorrect')
+    yield [Configuration(multiple_urls_config_file, index, mock_client, 'token2') for index in
-        self.assertDictEqual(self.configuration.headers, {'X-Cachet-Token': 'token2'}, 'Header was not set correctly')
+           range(len(multiple_urls_config_file['endpoints']))]
-        self.assertEqual(self.configuration.api_url, 'https://demo.cachethq.io/api/v1',
-                         'Cachet API URL was set incorrectly')
-        self.assertDictEqual(self.configuration.endpoint_header, {'SOME-HEADER': 'SOME-VALUE'}, 'Header is incorrect')
 
-    def test_evaluate(self):
-        def total_seconds():
-            return 0.1
 
-        def request(method, url, headers, timeout=None):
+def test_init(configuration):
-            response = mock.Mock()
+    assert len(configuration.data) == 2, 'Number of root elements in config.yml is incorrect'
-            response.status_code = 200
+    assert len(configuration.expectations) == 3, 'Number of expectations read from file is incorrect'
-            response.elapsed = mock.Mock()
+    assert configuration.headers == {'X-Cachet-Token': 'token2'}, 'Header was not set correctly'
-            response.elapsed.total_seconds = total_seconds
+    assert configuration.endpoint_header == {'SOME-HEADER': 'SOME-VALUE'}, 'Header is incorrect'
-            response.text = '<body>'
-            return response
 
-        sys.modules['requests'].request = request
-        self.configuration.evaluate()
 
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
+def test_init_unknown_status(config_file, mock_client):
-                         'Component status set incorrectly')
+    mock_client.get_component_status.return_value = cachet_url_monitor.status.ComponentStatus.UNKNOWN
+    configuration = Configuration(config_file, 0, mock_client, 'token2')
 
-    def test_evaluate_without_header(self):
+    assert configuration.previous_status == cachet_url_monitor.status.ComponentStatus.UNKNOWN
-        def total_seconds():
-            return 0.1
 
-        def request(method, url, headers=None, timeout=None):
-            response = mock.Mock()
-            response.status_code = 200
-            response.elapsed = mock.Mock()
-            response.elapsed.total_seconds = total_seconds
-            response.text = '<body>'
-            return response
 
-        sys.modules['requests'].request = request
+def test_evaluate(configuration):
-        self.configuration.evaluate()
+    with requests_mock.mock() as m:
+        m.get('http://localhost:8080/swagger', text='<body>')
+        configuration.evaluate()
 
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
+        assert configuration.status == cachet_url_monitor.status.ComponentStatus.OPERATIONAL, 'Component status set incorrectly'
-                         'Component status set incorrectly')
 
-    def test_evaluate_with_failure(self):
-        def total_seconds():
-            return 0.1
 
-        def request(method, url, headers, timeout=None):
+def test_evaluate_without_header(configuration):
-            response = mock.Mock()
+    with requests_mock.mock() as m:
-            # We are expecting a 200 response, so this will fail the expectation.
+        m.get('http://localhost:8080/swagger', text='<body>')
-            response.status_code = 400
+        configuration.evaluate()
-            response.elapsed = mock.Mock()
-            response.elapsed.total_seconds = total_seconds
-            response.text = '<body>'
-            return response
 
-        sys.modules['requests'].request = request
+        assert configuration.status == cachet_url_monitor.status.ComponentStatus.OPERATIONAL, 'Component status set incorrectly'
-        self.configuration.evaluate()
 
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_MAJOR_OUTAGE,
-                         'Component status set incorrectly or custom incident status is incorrectly parsed')
 
-    def test_evaluate_with_timeout(self):
+def test_evaluate_with_failure(configuration):
-        def request(method, url, headers, timeout=None):
+    with requests_mock.mock() as m:
-            self.assertEqual(method, 'GET', 'Incorrect HTTP method')
+        m.get('http://localhost:8080/swagger', text='<body>', status_code=400)
-            self.assertEqual(url, 'http://localhost:8080/swagger', 'Monitored URL is incorrect')
+        configuration.evaluate()
-            self.assertEqual(timeout, 0.010)
 
-            raise Timeout()
+        assert configuration.status == cachet_url_monitor.status.ComponentStatus.MAJOR_OUTAGE, 'Component status set incorrectly or custom incident status is incorrectly parsed'
 
-        sys.modules['requests'].request = request
-        self.configuration.evaluate()
 
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PERFORMANCE_ISSUES,
+def test_evaluate_with_timeout(configuration, mock_logger):
-                         'Component status set incorrectly')
+    with requests_mock.mock() as m:
-        self.mock_logger.warning.assert_called_with('Request timed out')
+        m.get('http://localhost:8080/swagger', exc=requests.Timeout)
+        configuration.evaluate()
 
-    def test_evaluate_with_connection_error(self):
+        assert configuration.status == cachet_url_monitor.status.ComponentStatus.PERFORMANCE_ISSUES, 'Component status set incorrectly'
-        def request(method, url, headers, timeout=None):
+        mock_logger.warning.assert_called_with('Request timed out')
-            self.assertEqual(method, 'GET', 'Incorrect HTTP method')
-            self.assertEqual(url, 'http://localhost:8080/swagger', 'Monitored URL is incorrect')
-            self.assertEqual(timeout, 0.010)
 
-            raise ConnectionError()
 
-        sys.modules['requests'].request = request
+def test_evaluate_with_connection_error(configuration, mock_logger):
-        self.configuration.evaluate()
+    with requests_mock.mock() as m:
+        m.get('http://localhost:8080/swagger', exc=requests.ConnectionError)
+        configuration.evaluate()
 
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PARTIAL_OUTAGE,
+        assert configuration.status == cachet_url_monitor.status.ComponentStatus.PARTIAL_OUTAGE, 'Component status set incorrectly'
-                         'Component status set incorrectly')
+        mock_logger.warning.assert_called_with('The URL is unreachable: GET http://localhost:8080/swagger')
-        self.mock_logger.warning.assert_called_with('The URL is unreachable: GET http://localhost:8080/swagger')
 
-    def test_evaluate_with_http_error(self):
-        def request(method, url, headers, timeout=None):
-            self.assertEqual(method, 'GET', 'Incorrect HTTP method')
-            self.assertEqual(url, 'http://localhost:8080/swagger', 'Monitored URL is incorrect')
-            self.assertEqual(timeout, 0.010)
 
-            raise HTTPError()
+def test_evaluate_with_http_error(configuration, mock_logger):
+    with requests_mock.mock() as m:
+        m.get('http://localhost:8080/swagger', exc=requests.HTTPError)
+        configuration.evaluate()
 
-        sys.modules['requests'].request = request
+        assert configuration.status == cachet_url_monitor.status.ComponentStatus.PARTIAL_OUTAGE, 'Component status set incorrectly'
-        self.configuration.evaluate()
+        mock_logger.exception.assert_called_with('Unexpected HTTP response')
 
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_PARTIAL_OUTAGE,
-                         'Component status set incorrectly')
-        self.mock_logger.exception.assert_called_with('Unexpected HTTP response')
 
-    def test_push_status(self):
+def test_push_status(configuration, mock_client):
-        def put(url, params=None, headers=None):
+    mock_client.get_component_status.return_value = cachet_url_monitor.status.ComponentStatus.PARTIAL_OUTAGE
-            self.assertEqual(url, 'https://demo.cachethq.io/api/v1/components/1', 'Incorrect cachet API URL')
+    push_status_response = mock.Mock()
-            self.assertDictEqual(params, {'id': 1, 'status': 1}, 'Incorrect component update parameters')
+    mock_client.push_status.return_value = push_status_response
-            self.assertDictEqual(headers, {'X-Cachet-Token': 'token2'}, 'Incorrect component update parameters')
+    push_status_response.ok = True
+    configuration.previous_status = cachet_url_monitor.status.ComponentStatus.PARTIAL_OUTAGE
+    configuration.status = cachet_url_monitor.status.ComponentStatus.OPERATIONAL
 
-            response = mock.Mock()
+    configuration.push_status()
-            response.status_code = 200
-            return response
 
-        sys.modules['requests'].put = put
+    mock_client.push_status.assert_called_once_with(1, cachet_url_monitor.status.ComponentStatus.OPERATIONAL)
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
-                         'Incorrect component update parameters')
-        self.configuration.push_status()
 
-    def test_push_status_with_failure(self):
-        def put(url, params=None, headers=None):
-            self.assertEqual(url, 'https://demo.cachethq.io/api/v1/components/1', 'Incorrect cachet API URL')
-            self.assertDictEqual(params, {'id': 1, 'status': 1}, 'Incorrect component update parameters')
-            self.assertDictEqual(headers, {'X-Cachet-Token': 'token2'}, 'Incorrect component update parameters')
 
-            response = mock.Mock()
+def test_push_status_with_new_failure(configuration, mock_client):
-            response.status_code = 400
+    mock_client.get_component_status.return_value = cachet_url_monitor.status.ComponentStatus.OPERATIONAL
-            return response
+    push_status_response = mock.Mock()
+    mock_client.push_status.return_value = push_status_response
+    push_status_response.ok = False
+    configuration.status = cachet_url_monitor.status.ComponentStatus.PARTIAL_OUTAGE
 
-        sys.modules['requests'].put = put
+    configuration.push_status()
-        self.assertEqual(self.configuration.status, cachet_url_monitor.status.COMPONENT_STATUS_OPERATIONAL,
+
-                         'Incorrect component update parameters')
+    mock_client.push_status.assert_called_once_with(1, cachet_url_monitor.status.ComponentStatus.PARTIAL_OUTAGE)
-        self.configuration.push_status()
+
+
+def test_push_status_same_status(configuration, mock_client):
+    mock_client.get_component_status.return_value = cachet_url_monitor.status.ComponentStatus.OPERATIONAL
+    configuration.status = cachet_url_monitor.status.ComponentStatus.OPERATIONAL
+
+    configuration.push_status()
+
+    mock_client.push_status.assert_not_called()
+
+
+def test_init_multiple_urls(multiple_urls_configuration):
+    expected_method = ['GET', 'POST']
+    expected_url = ['http://localhost:8080/swagger', 'http://localhost:8080/bar']
+
+    assert len(multiple_urls_configuration) == 2
+    for index in range(len(multiple_urls_configuration)):
+        config = multiple_urls_configuration[index]
+        assert len(config.data) == 2, 'Number of root elements in config.yml is incorrect'
+        assert len(config.expectations) == 1, 'Number of expectations read from file is incorrect'
+        assert config.headers == {'X-Cachet-Token': 'token2'}, 'Header was not set correctly'
+
+        assert expected_method[index] == config.endpoint_method
+        assert expected_url[index] == config.endpoint_url
+
+
+def test_init_invalid_configuration(invalid_config_file, mock_client):
+    with pytest.raises(cachet_url_monitor.configuration.ConfigurationValidationError):
+        Configuration(invalid_config_file, 0, mock_client, 'token2')

tests/test_expectation.py

@@ -5,8 +5,8 @@ import unittest
 import mock
 import pytest
 
-from cachet_url_monitor.configuration import HttpStatus, Regex
+from cachet_url_monitor.expectation import HttpStatus, Regex, Latency
-from cachet_url_monitor.configuration import Latency
+from cachet_url_monitor.status import ComponentStatus
 
 
 class LatencyTest(unittest.TestCase):
@@ -25,7 +25,7 @@ class LatencyTest(unittest.TestCase):
         request.elapsed = elapsed
         elapsed.total_seconds = total_seconds
 
-        assert self.expectation.get_status(request) == 1
+        assert self.expectation.get_status(request) == ComponentStatus.OPERATIONAL
 
     def test_get_status_unhealthy(self):
         def total_seconds():
@@ -36,7 +36,7 @@ class LatencyTest(unittest.TestCase):
         request.elapsed = elapsed
         elapsed.total_seconds = total_seconds
 
-        assert self.expectation.get_status(request) == 2
+        assert self.expectation.get_status(request) == ComponentStatus.PERFORMANCE_ISSUES
 
     def test_get_message(self):
         def total_seconds():
@@ -73,13 +73,25 @@ class HttpStatusTest(unittest.TestCase):
         request = mock.Mock()
         request.status_code = 200
 
-        assert self.expectation.get_status(request) == 1
+        assert self.expectation.get_status(request) == ComponentStatus.OPERATIONAL
+
+    def test_get_status_healthy_boundary(self):
+        request = mock.Mock()
+        request.status_code = 299
+
+        assert self.expectation.get_status(request) == ComponentStatus.OPERATIONAL
 
     def test_get_status_unhealthy(self):
         request = mock.Mock()
         request.status_code = 400
 
-        assert self.expectation.get_status(request) == 3
+        assert self.expectation.get_status(request) == ComponentStatus.PARTIAL_OUTAGE
+
+    def test_get_status_unhealthy_boundary(self):
+        request = mock.Mock()
+        request.status_code = 300
+
+        assert self.expectation.get_status(request) == ComponentStatus.PARTIAL_OUTAGE
 
     def test_get_message(self):
         request = mock.Mock()
@@ -100,13 +112,13 @@ class RegexTest(unittest.TestCase):
         request = mock.Mock()
         request.text = 'We could find stuff\n in this body.'
 
-        assert self.expectation.get_status(request) == 1
+        assert self.expectation.get_status(request) == ComponentStatus.OPERATIONAL
 
     def test_get_status_unhealthy(self):
         request = mock.Mock()
         request.text = 'We will not find it here'
 
-        assert self.expectation.get_status(request) == 3
+        assert self.expectation.get_status(request) == ComponentStatus.PARTIAL_OUTAGE
 
     def test_get_message(self):
         request = mock.Mock()

tests/test_scheduler.py

@@ -3,7 +3,6 @@ import sys
 import unittest
 
 import mock
-from yaml import load, SafeLoader
 
 sys.modules['schedule'] = mock.Mock()
 from cachet_url_monitor.scheduler import Agent, Scheduler
@@ -46,13 +45,43 @@ class SchedulerTest(unittest.TestCase):
 
         mock_requests.get = get
 
-        self.scheduler = Scheduler(load(open('config.yml', 'r'), SafeLoader), 0)
+        self.agent = mock.MagicMock()
+
+        self.scheduler = Scheduler(
+            {
+                'endpoints': [
+                    {
+                        'name': 'foo',
+                        'url': 'http://localhost:8080/swagger',
+                        'method': 'GET',
+                        'expectation': [
+                            {
+                                'type': 'HTTP_STATUS',
+                                'status_range': '200 - 300',
+                                'incident': 'MAJOR',
+                            }
+                        ],
+                        'allowed_fails': 0,
+                        'component_id': 1,
+                        'action': ['CREATE_INCIDENT', 'UPDATE_STATUS'],
+                        'public_incidents': True,
+                        'latency_unit': 'ms',
+                        'frequency': 30
+                    }
+                ],
+                'cachet': {
+                    'api_url': 'https: // demo.cachethq.io / api / v1',
+                    'token': 'my_token'
+                }
+            }, self.agent)
 
     def test_init(self):
-        assert self.scheduler.stop == False
+        self.assertFalse(self.scheduler.stop)
 
     def test_start(self):
         # TODO(mtakaki|2016-05-01): We need a better way of testing this method.
         # Leaving it as a placeholder.
         self.scheduler.stop = True
         self.scheduler.start()
+
+        self.agent.start.assert_called()