Merge ~gabrielcocenza/juju-lint:bug/1965762-B into juju-lint:master

[Gabriel Cocenza]

added new rule for checking relations.

Closes-Bug: #1965762, #1975548

Added a new rule to check relations.

pastebin of unit tests [0] after rebasing with 100% coverage

[0] https://pastebin.canonical.com/p/k4FgszYdhf/

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[Martin Kalcok (martin-kalcok)]

Overall this change looks great. Thanks. I do have few comments/questions, see inline pls.

review: Needs Information

[Gabriel Cocenza (gabrielcocenza)]

Thanks for your review Martin. Good points.

[Eric Chen (eric-chen)]

LGTM.. But I would like to

1. Merge Martin's MP first.
2. Verify unit/func test in this MP and provide the log.

[Gabriel Cocenza (gabrielcocenza)]

pastebin of unit tests [0] after rebase, with 100% coverage

[0] https://pastebin.canonical.com/p/k4FgszYdhf/

[Eric Chen (eric-chen)]

What about lint/func test?

review: Needs Information

[Gabriel Cocenza (gabrielcocenza)]

Rebased with last master commit with functional tests, squashed commits, results of lint, unit and functional tests [0]

[0] https://pastebin.canonical.com/p/MzKvj7Y8hQ/

[Martin Kalcok (martin-kalcok)]

LGTM, thanks.

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision e41480d686387ef10326f9d54c26301297761f12

diff --git a/contrib/includes/aggregator-kubernetes.yaml b/contrib/includes/aggregator-kubernetes.yaml
index 95c2099..cf4607f 100644
--- a/contrib/includes/aggregator-kubernetes.yaml
+++ b/contrib/includes/aggregator-kubernetes.yaml
@@ -14,3 +14,7 @@ known charms:
   - ubuntu
   - *operations-charms
   - *kubernetes-charms
+
+relations:
+  - *relations-base-check
+  - *kubernetes-relation-checks
diff --git a/contrib/includes/aggregator-openstack.yaml b/contrib/includes/aggregator-openstack.yaml
index 58a92fa..d8c1305 100644
--- a/contrib/includes/aggregator-openstack.yaml
+++ b/contrib/includes/aggregator-openstack.yaml
@@ -20,3 +20,6 @@ known charms:
   - ubuntu
   - *openstack-charms
   - *operations-charms
+
+relations:
+  - *relations-base-check
diff --git a/contrib/includes/base.yaml b/contrib/includes/base.yaml
index 0e171e3..2ab4712 100644
--- a/contrib/includes/base.yaml
+++ b/contrib/includes/base.yaml
@@ -43,3 +43,10 @@ subordinates:
   where: all
  local-users:
   where: all or nothing
+
+# openstack and k8s should check nrpe relations. See LP#1965762
+relations base check: &relations-base-check
+  - charm: nrpe
+    check: [
+      ["*:nrpe-external-master", "nrpe:nrpe-external-master"]
+    ]
diff --git a/contrib/includes/kubernetes.yaml b/contrib/includes/kubernetes.yaml
index 2ade8ed..bbb5e90 100644
--- a/contrib/includes/kubernetes.yaml
+++ b/contrib/includes/kubernetes.yaml
@@ -22,3 +22,13 @@ kubernetes optional charms: &kubernetes-optional-charms
  - kubernetes-dashboard
  - openstack-integrator
  - vsphere-integrator
+
+# See LP#1975548
+kubernetes relation checks: &kubernetes-relation-checks
+  - charm: openstack-integrator
+    check: [
+      ["kubernetes-control-plane:loadbalancer", "openstack-integrator:loadbalancer"]
+    ]
+    not-exist: [
+      ["kubernetes-control-plane:kube-api-endpoint", "kubernetes-worker:kube-api-endpoint"]
+    ]
diff --git a/jujulint/lint.py b/jujulint/lint.py
index a931d55..937733e 100755
--- a/jujulint/lint.py
+++ b/jujulint/lint.py
@@ -36,6 +36,7 @@ from dateutil import relativedelta
 import jujulint.util as utils
 from jujulint.check_spaces import Relation, find_space_mismatches
 from jujulint.logging import Logger
+from jujulint.relations import RelationError, RelationsRulesBootStrap
 
 VALID_CONFIG_CHECKS = ("isset", "eq", "neq", "gte", "search")
 
@@ -67,6 +68,7 @@ class ModelInfo(object):
     charms = attrib(default=attr.Factory(set))
     cmr_apps = attrib(default=attr.Factory(set))
     app_to_charm = attrib(default=attr.Factory(dict))
+    charm_to_app = attrib(default=attr.Factory(dict))
     subs_on_machines = attrib(default=attr.Factory(dict))
     apps_on_machines = attrib(default=attr.Factory(dict))
     machines_to_az = attrib(default=attr.Factory(dict))
@@ -611,6 +613,49 @@ class Linter:
             if not self.model.extraneous_subs[sub]:
                 del self.model.extraneous_subs[sub]
 
+    def check_relations(self, applications):
+        """Check the relations in the rules file.
+
+        :param applications: applications present in the model
+        :type applications: Dict
+        """
+        if "relations" not in self.lint_rules:
+            self._log_with_header("No relation rules found. Skipping relation checks")
+            return
+        try:
+            relations_rules = RelationsRulesBootStrap(
+                charm_to_app=self.model.charm_to_app,
+                relations_rules=self.lint_rules["relations"],
+                applications=applications,
+            ).check()
+        except RelationError as e:
+            relations_rules = []
+            self._log_with_header(e.message, level=logging.ERROR)
+
+        for rule in relations_rules:
+            for endpoint, applications in rule.missing_relations.items():
+                if applications:
+                    self.handle_error(
+                        {
+                            "id": "missing-relations",
+                            "tags": ["relation", "missing"],
+                            "message": "Endpoint '{}' is missing relations with: {}".format(
+                                endpoint, applications
+                            ),
+                        }
+                    )
+            if rule.not_exist_error:
+                for relation in rule.not_exist_error:
+                    self.handle_error(
+                        {
+                            "id": "relation-exist",
+                            "tags": ["relation", "exist"],
+                            "message": "Relation(s) {} should not exist.".format(
+                                relation
+                            ),
+                        }
+                    )
+
     def check_charms_ops_mandatory(self, charm):
         """
         Check if a mandatory ops charms is present in the model.
@@ -928,6 +973,7 @@ class Linter:
                 charm_name = utils.extract_charm_name(applications[app]["charm"])
                 self.model.charms.add(charm_name)
                 self.model.app_to_charm[app] = charm_name
+                self.model.charm_to_app.setdefault(charm_name, set()).add(app)
             else:
                 self.handle_error(
                     {
@@ -1205,6 +1251,7 @@ class Linter:
                 self.process_subordinates(parsed_yaml[applications][app], app)
 
             self.check_subs(parsed_yaml["machines"])
+            self.check_relations(parsed_yaml[applications])
             self.check_charms()
 
             if "relations" in parsed_yaml:
diff --git a/jujulint/relations.py b/jujulint/relations.py
new file mode 100644
index 0000000..b6a39d2
--- /dev/null
+++ b/jujulint/relations.py
@@ -0,0 +1,296 @@
+#!/usr/bin/python3
+"""Checks relations between applications."""
+from logging import getLogger
+from typing import Any, Dict, List, Set, Tuple
+
+LOGGER = getLogger(__name__)
+
+
+class RelationError(Exception):
+    """Special exception for relations errors."""
+
+    def __init__(self, msg: str):
+        """Relation error message format.
+
+        :param msg: Message of the exception found.
+        :type msg: str
+        """
+        self.message = f"{self.__class__.__name__}: {msg}"
+
+
+class RelationRule:
+    """Object to check the relations rules."""
+
+    def __init__(
+        self,
+        charm_to_app: Set,
+        applications: Dict[str, Any],
+        charm: str,
+        relations: List[List[str]],
+        not_exist: List[List[str]],
+        exception: Set,
+    ):
+        """Relation Rule object.
+
+        :param charm_to_app: A charm can have more than one application name
+            e.g:(nrpe-host and nrpe-container). This parameters contains all
+            applications name of a given charm.
+        :type charm_to_app: Set
+        :param applications: All applications of the file passed to lint.
+        :type applications: Dict[str, Any]
+        :param charm: Name of the charm to check the relations rules.
+        :type charm: str
+        :param relations: Relations that should be checked of a given charm
+            having the following format:
+            [[<application>:<application_endpoint>, <application>:<application_endpoint>]]
+            If <application> == "*" it will check the relation using the endpoint
+            on all applications form the file passed.
+        :type relations: List[List[str]]
+        :param not_exist: Relation that should not exist in the presence of the
+            relations passed to be checked. This parameter has the following format:
+            [[<application>:<application_endpoint>, <application>:<application_endpoint>]]
+        :type not_exist: List[List[str]],
+        :param exception: Set of applications that the rule doesn't apply to.
+        :type exception: Set
+        """
+        self.charm_to_app = charm_to_app
+        self.applications = applications
+        self.charm = charm
+        self.relations = relations
+        self.not_exist = not_exist
+        self.exception = exception
+        # remove all possible app names from the subordinate app to not check itself
+        self.apps_to_check = set(self.applications.keys()) - self.charm_to_app
+        self.missing_relations = dict()
+        self.not_exist_error = list()
+
+    @property
+    def relations(self) -> List[List[str]]:
+        """Relations to be checked in a charm.
+
+        :return: List of list containing the app and endpoint to check,
+            with the following format: [[app_to_check, endpoint_to_check]]
+        :rtype: List[List[str]]
+        """
+        return self._relations
+
+    @relations.setter
+    def relations(self, raw_relations_rules: List[List[str]]) -> None:
+        """Relation setter of a rule.
+
+        :param raw_relations_rules: Relations that should be checked of a given charm
+            having the following format:
+            [[<application_1>:<endpoint>], [<application_2>:<endpoint>]]
+        :type raw_relations_rules: List[List[str]]
+        :raises RelationError:  Raises RelationError if not in expected format.
+        """
+        self._relations = []
+        if not all(raw_relations_rules):
+            return
+        for relation_rule in raw_relations_rules:
+            try:
+                app_0, endpoint_0 = self.check_app_endpoint_existence(relation_rule[0])
+                app_1, endpoint_1 = self.check_app_endpoint_existence(relation_rule[1])
+                if not all([app_0, endpoint_0, app_1, endpoint_1]):
+                    # means that app or endpoint was not found
+                    return
+                if app_0 == self.charm:
+                    self.endpoint = endpoint_0
+                    app_to_check = app_1
+                    endpoint_to_check = endpoint_1
+                elif app_1 == self.charm:
+                    self.endpoint = endpoint_1
+                    app_to_check = app_0
+                    endpoint_to_check = endpoint_0
+                else:
+                    msg = (
+                        "Relations rules has an unexpected format. "
+                        f"It was not possible to find {self.charm} on rules"
+                    )
+                    LOGGER.warning(msg)
+                    return
+
+                # check if all apps variations has the endpoint
+                for app in self.charm_to_app:
+                    self.check_app_endpoint_existence(f"{app}:{self.endpoint}")
+                self._relations.append([app_to_check, endpoint_to_check])
+            except (IndexError, ValueError) as e:
+                raise RelationError(f"Relations rules has an unexpected format: {e}")
+
+    def __repr__(self) -> str:
+        """Representation of the RelationRule object.
+
+        :return: representation.
+        :rtype: str
+        """
+        return f"{self.__class__.__name__}({self.charm} -> {self.endpoint})"
+
+    def check(self) -> None:
+        """Apply the relations rules check."""
+        self.relation_exist_check()
+        self.relation_not_exist_check()
+
+    def filter_by_app_and_endpoint(self, app: str, endpoint: str) -> Set:
+        """Filter applications by the presence of an endpoint.
+
+        :param app: Application to be filtered.
+        :type app: str
+        :param endpoint: Endpoint of a application.
+        :type endpoint: str
+        :return: Applications that matched with the endpoint passed.
+        :rtype: Set
+        """
+        # NOTE(gabrielcocenza) this function just works with fields from juju status.
+        # when app == "*", filters all apps that have the endpoint passed.
+        if app == "*":
+            return {
+                app
+                for app in self.apps_to_check
+                if endpoint
+                in self.applications.get(app, {}).get("endpoint-bindings", {})
+            }
+        return (
+            set([app])
+            if endpoint in self.applications.get(app, {}).get("endpoint-bindings", {})
+            else set()
+        )
+
+    def filter_by_relation(self, apps: Set, endpoint: str) -> Set:
+        """Filter applications that relate with an endpoint.
+
+        :param apps: Applications to filter relations using the endpoint.
+        :type apps: Set
+        :param endpoint: endpoint of the applications.
+        :type endpoint: str
+        :return: Applications that has a relation with the apps using the endpoint.
+        :rtype: Set
+        """
+        # NOTE(gabrielcocenza) this function just works with fields from juju status.
+        apps_related = set()
+        for app in apps:
+            relations = self.applications.get(app, {}).get("relations", {})
+            apps_related.update(relations.get(endpoint, []))
+        return apps_related
+
+    def relation_exist_check(self) -> None:
+        """Check if app(s) are relating with an endpoint."""
+        for relation in self.relations:
+            app_to_check, endpoint_to_check = relation
+            # applications in the bundle that have the endpoint to relate
+            apps_with_endpoint_to_check = self.filter_by_app_and_endpoint(
+                app_to_check,
+                endpoint_to_check,
+            )
+            # applications that are relating using the endpoint from the relation rule
+            apps_related_with_relation_rule = self.filter_by_relation(
+                self.charm_to_app,
+                self.endpoint,
+            )
+            self.missing_relations[f"{self.charm}:{self.endpoint}"] = sorted(
+                list(
+                    apps_with_endpoint_to_check
+                    - apps_related_with_relation_rule
+                    - self.exception
+                )
+            )
+
+    def relation_not_exist_check(self) -> None:
+        """Check if a relation happens when it shouldn't.
+
+        :raises RelationError: raise RelationError if it has wrong format.
+        """
+        for relation in self.not_exist:
+            if relation:
+                app_endpoint_splitted = []
+                try:
+                    for app_endpoint in relation:
+                        app, endpoint = self.check_app_endpoint_existence(app_endpoint)
+                        app_endpoint_splitted.extend([app, endpoint])
+                    (
+                        app_to_check_0,
+                        endpoint_to_check_0,
+                        app_to_check_1,
+                        _,
+                    ) = app_endpoint_splitted
+                    relations_app_endpoint_0 = self.filter_by_relation(
+                        {app_to_check_0}, endpoint_to_check_0
+                    )
+                    if app_to_check_1 in relations_app_endpoint_0:
+                        self.not_exist_error.append(relation)
+
+                except (IndexError, ValueError) as e:
+                    raise RelationError(f"Problem during check_relation_not_exist: {e}")
+
+    def check_app_endpoint_existence(self, app_endpoint: str) -> Tuple[str, str]:
+        """Check if app and endpoint exist on the object to lint.
+
+        :param app_endpoint: app and endpoint separated by ":" with the following format:
+            <application>:<application_endpoint>
+        :type app_endpoint: str
+        :return: application and endpoint
+        :rtype: Tuple[str, str]
+        """
+        app, endpoint = app_endpoint.split(":")
+        # app == "*" means all apps
+        # a charm from relation rule can have different app names.
+        if app != "*" and app != self.charm:
+            if app not in self.applications.keys():
+                LOGGER.warning(f"{app} not found on applications to check relations")
+                return "", ""
+
+            # juju-info is represented by "" on endpoint-bindings
+            if endpoint != "juju-info" and endpoint not in self.applications[app].get(
+                "endpoint-bindings", {}
+            ):
+                LOGGER.warning(
+                    f"{app} don't have the endpoint: {endpoint} to check relations"
+                )
+                return "", ""
+        return app, endpoint
+
+
+class RelationsRulesBootStrap:
+    """Bootstrap all relations rules to be checked."""
+
+    def __init__(
+        self,
+        charm_to_app: Dict[str, Set],
+        relations_rules: List[Dict[str, Any]],
+        applications: Dict[str, Any],
+    ):
+        """Relations rules bootStrap object.
+
+        :param charm_to_app: A charm can have more than one application name
+            e.g:(nrpe-host and nrpe-container). This parameters contains all
+            applications name of a given charm.
+        :type charm_to_app: Dict[str, Set]
+        :param relations_rules: Relations rules from the rule file.
+        :type relations_rules: List[Dict[str, Any]]
+        :param applications: All applications of the file passed to lint.
+        :type applications: Dict[str, Any]
+        """
+        self.charm_to_app = charm_to_app
+        self.relations_rules = relations_rules
+        self.applications = applications
+
+    def check(self) -> List[RelationRule]:
+        """Check all RelationRule objects.
+
+        :return: List containing all RelationRule objects.
+        :rtype: List[RelationRule]
+        """
+        relations_rules = [
+            RelationRule(
+                charm_to_app=self.charm_to_app.get(rule.get("charm", ""), set()),
+                applications=self.applications,
+                charm=rule.get("charm"),
+                relations=rule.get("check", [[]]),
+                not_exist=rule.get("not-exist", [[]]),
+                exception=set(rule.get("exception", set())),
+            )
+            for rule in self.relations_rules
+        ]
+
+        for rule in relations_rules:
+            rule.check()
+        return relations_rules
diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py
index a70ef63..4d3d3ee 100644
--- a/tests/unit/conftest.py
+++ b/tests/unit/conftest.py
@@ -107,6 +107,10 @@ def juju_status():
                 "charm": "cs:ubuntu-18",
                 "charm-name": "ubuntu",
                 "relations": {"juju-info": ["ntp"]},
+                "endpoint-bindings": {
+                    "": "external-space",
+                    "certificates": "external-space",
+                },
                 "units": {
                     "ubuntu/0": {
                         "juju-status": {"current": "idle"},
@@ -126,6 +130,10 @@ def juju_status():
                 "charm": "cs:ntp-47",
                 "charm-name": "ntp",
                 "relations": {"juju-info": ["ubuntu"]},
+                "endpoint-bindings": {
+                    "": "external-space",
+                    "certificates": "external-space",
+                },
             },
         },
         "machines": {
@@ -229,3 +237,84 @@ def rules_files():
     return [
         str(rule.resolve()) for rule in Path("./contrib").iterdir() if rule.is_file()
     ]
+
+
+def juju_status_relation():
+    """Representation of juju status input to test relations checks."""
+    return {
+        "nrpe-container": {
+            "charm": "cs:nrpe-61",
+            "charm-name": "nrpe",
+            "relations": {
+                "monitors": ["nagios"],
+                "nrpe-external-master": [
+                    "keystone",
+                ],
+            },
+            "endpoint-bindings": {
+                "general-info": "",
+                "local-monitors": "",
+                "monitors": "oam-space",
+                "nrpe": "",
+                "nrpe-external-master": "",
+            },
+        },
+        "nrpe-host": {
+            "charm": "cs:nrpe-67",
+            "charm-name": "nrpe",
+            "relations": {
+                "monitors": ["nagios"],
+                "nrpe-external-master": [
+                    "elasticsearch",
+                ],
+            },
+            "endpoint-bindings": {
+                "general-info": "",
+                "local-monitors": "",
+                "monitors": "oam-space",
+                "nrpe": "",
+                "nrpe-external-master": "",
+            },
+        },
+        "keystone": {
+            "charm": "cs:keystone-309",
+            "charm-name": "keystone",
+            "relations": {
+                "nrpe-external-master": ["nrpe-container"],
+            },
+            "endpoint-bindings": {
+                "": "oam-space",
+                "admin": "external-space",
+                "certificates": "oam-space",
+                "cluster": "oam-space",
+                "domain-backend": "oam-space",
+                "ha": "oam-space",
+                "identity-admin": "oam-space",
+                "identity-credentials": "oam-space",
+                "identity-notifications": "oam-space",
+                "identity-service": "oam-space",
+                "internal": "internal-space",
+                "keystone-fid-service-provider": "oam-space",
+                "keystone-middleware": "oam-space",
+                "nrpe-external-master": "oam-space",
+                "public": "external-space",
+                "shared-db": "internal-space",
+                "websso-trusted-dashboard": "oam-space",
+            },
+        },
+        "elasticsearch": {
+            "charm": "cs:elasticsearch-39",
+            "charm-name": "elasticsearch",
+            "relations": {
+                "nrpe-external-master": ["nrpe-host"],
+            },
+            "endpoint-bindings": {
+                "": "oam-space",
+                "client": "oam-space",
+                "data": "oam-space",
+                "logs": "oam-space",
+                "nrpe-external-master": "oam-space",
+                "peer": "oam-space",
+            },
+        },
+    }
diff --git a/tests/unit/test_jujulint.py b/tests/unit/test_jujulint.py
index 4394835..136044b 100644
--- a/tests/unit/test_jujulint.py
+++ b/tests/unit/test_jujulint.py
@@ -7,7 +7,7 @@ from unittest import mock
 import pytest
 import yaml
 
-from jujulint import check_spaces, lint
+from jujulint import check_spaces, lint, relations
 
 
 class TestUtils:
@@ -1232,3 +1232,72 @@ applications:
     def test_linter_atoi(self, input_str, expected_int, linter):
         """Test conversion of string values (e.g. 2M (Megabytes)) to integers."""
         assert linter.atoi(input_str) == expected_int
+
+    def test_check_relations_no_rules(self, linter, juju_status, mocker):
+        """Warn message if rule file doesn't pass relations to check."""
+        mock_log = mocker.patch("jujulint.lint.Linter._log_with_header")
+        linter.check_relations(juju_status["applications"])
+        mock_log.assert_called_with("No relation rules found. Skipping relation checks")
+
+    def test_check_relations(self, linter, juju_status, mocker):
+        """Ensure that check_relation pass."""
+        mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
+        linter.lint_rules["relations"] = [
+            {"charm": "ntp", "check": [["ntp:juju-info", "ubuntu:juju-info"]]}
+        ]
+        linter.check_relations(juju_status["applications"])
+        mock_handle_error.assert_not_called()
+
+    def test_check_relations_exception_handling(self, linter, juju_status, mocker):
+        """Ensure that handle error if relation rules are in wrong format."""
+        mock_log = mocker.patch("jujulint.lint.Linter._log_with_header")
+        mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
+        linter.lint_rules["relations"] = [
+            {"charm": "ntp", "check": [["ntp", "ubuntu"]]}
+        ]
+        expected_msg = (
+            "Relations rules has an unexpected format: not enough "
+            "values to unpack (expected 2, got 1)"
+        )
+        expected_exception = relations.RelationError(expected_msg)
+        linter.check_relations(juju_status["applications"])
+        mock_handle_error.assert_not_called()
+        mock_log.assert_has_calls(
+            [mocker.call(expected_exception.message, level=logging.ERROR)]
+        )
+
+    def test_check_relations_missing_relations(self, linter, juju_status, mocker):
+        """Ensure that check_relation handle missing relations."""
+        mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
+        # add a relation rule that doesn't happen in the model
+        linter.lint_rules["relations"] = [
+            {"charm": "ntp", "check": [["ntp:certificates", "ubuntu:certificates"]]}
+        ]
+        linter.check_relations(juju_status["applications"])
+        mock_handle_error.assert_called_with(
+            {
+                "id": "missing-relations",
+                "tags": ["relation", "missing"],
+                "message": "Endpoint '{}' is missing relations with: {}".format(
+                    "ntp:certificates", ["ubuntu"]
+                ),
+            }
+        )
+
+    def test_check_relations_exist(self, linter, juju_status, mocker):
+        """Ensure that check_relation handle not exist error."""
+        mock_handle_error = mocker.patch("jujulint.lint.Linter.handle_error")
+        # add a relation rule that happen in the model
+        linter.lint_rules["relations"] = [
+            {"charm": "ntp", "not-exist": [["ntp:juju-info", "ubuntu:juju-info"]]}
+        ]
+        linter.check_relations(juju_status["applications"])
+        mock_handle_error.assert_called_with(
+            {
+                "id": "relation-exist",
+                "tags": ["relation", "exist"],
+                "message": "Relation(s) {} should not exist.".format(
+                    ["ntp:juju-info", "ubuntu:juju-info"]
+                ),
+            }
+        )
diff --git a/tests/unit/test_relations.py b/tests/unit/test_relations.py
new file mode 100644
index 0000000..9ec5d72
--- /dev/null
+++ b/tests/unit/test_relations.py
@@ -0,0 +1,208 @@
+#!/usr/bin/python3
+"""Test the relations module."""
+import pytest
+
+from jujulint import relations
+
+CHARM_TO_APP = {"nrpe-host", "nrpe-container"}
+CHARM = "nrpe"
+# rule to check all charms with nrpe-external-master endpoint.
+RELATIONS = [["*:nrpe-external-master", "nrpe:nrpe-external-master"]]
+
+
[e-mail](
+    "correct_relation",
+    [
+        RELATIONS,
+        [
+            ["nrpe:nrpe-external-master", "*:nrpe-external-master"]
+        ],  # inverting sequence doesn't change the endpoint
+        [
+            ["nrpe:nrpe-external-master", "keystone:nrpe-external-master"]
+        ],  # able to find specific app relation
+    ],
+)
+def test_relation_rule_valid(correct_relation, juju_status_relation):
+    """Missing rules have empty set for endpoints with expected relations."""
+    relation_rule = relations.RelationRule(
+        charm_to_app=CHARM_TO_APP,
+        applications=juju_status_relation,
+        charm=CHARM,
+        relations=correct_relation,
+        not_exist=[[]],
+        exception=set(),
+    )
+    relation_rule.check()
+    assert relation_rule.missing_relations == {"nrpe:nrpe-external-master": list()}
+    assert relation_rule.not_exist_error == list()
+    assert relation_rule.__repr__() == "RelationRule(nrpe -> nrpe-external-master)"
+    assert relation_rule.endpoint == "nrpe-external-master"
+
+
+def test_relation_not_exist(juju_status_relation):
+    """Ensure that finds a relation that shouldn't happen."""
+    juju_status_relation["foo-charm"] = {
+        "charm": "cs:foo-charm-7",
+        "charm-name": "foo-charm",
+        "relations": {
+            "foo-endpoint": ["keystone"],
+        },
+        "endpoint-bindings": {
+            "": "oam-space",
+            "foo-endpoint": "oam-space",
+        },
+    }
+    juju_status_relation["keystone"]["relations"]["foo-endpoint"] = ["foo-charm"]
+    juju_status_relation["keystone"]["endpoint-bindings"]["foo-endpoint"] = "oam-space"
+    relation_rule = relations.RelationRule(
+        charm_to_app=CHARM_TO_APP,
+        applications=juju_status_relation,
+        charm=CHARM,
+        relations=RELATIONS,
+        not_exist=[["keystone:foo-endpoint", "foo-charm:foo-endpoint"]],
+        exception=set(),
+    )
+    relation_rule.check()
+    assert relation_rule.not_exist_error == [
+        ["keystone:foo-endpoint", "foo-charm:foo-endpoint"]
+    ]
+
+
+def test_relation_not_exist_raise(juju_status_relation):
+    """Test that raise exception when not_exist has wrong format."""
+    juju_status_relation["foo-charm"] = {
+        "charm": "cs:foo-charm-7",
+        "charm-name": "foo-charm",
+        "relations": {
+            "bar-endpoint": ["keystone"],
+        },
+        "endpoint-bindings": {
+            "": "oam-space",
+            "bar-endpoint": "oam-space",
+        },
+    }
+
+    with pytest.raises(relations.RelationError):
+        relation_rule = relations.RelationRule(
+            charm_to_app=CHARM_TO_APP,
+            applications=juju_status_relation,
+            charm=CHARM,
+            relations=RELATIONS,
+            not_exist=[["keystone", "foo-charm:foo-endpoint"]],
+            exception=set(),
+        )
+        relation_rule.check()
+
+
[e-mail](
+    "expected_missing, exception",
+    [
+        ({"nrpe:nrpe-external-master": ["foo-charm"]}, set()),
+        ({"nrpe:nrpe-external-master": list()}, {"foo-charm"}),
+    ],
+)
+def test_missing_relation_and_exception(
+    expected_missing, exception, juju_status_relation
+):
+    """Assert that exception is able to remove apps missing the relation."""
+    # add a charm in apps that has the endpoint nrpe-external-master,
+    # but it's not relating with nrpe.
+    juju_status_relation["foo-charm"] = {
+        "charm": "cs:foo-charm-7",
+        "charm-name": "foo-charm",
+        "relations": {
+            "foo-endpoint": ["bar-charm"],
+        },
+        "endpoint-bindings": {
+            "": "oam-space",
+            "nrpe-external-master": "oam-space",
+        },
+    }
+    relation_rule = relations.RelationRule(
+        charm_to_app=CHARM_TO_APP,
+        applications=juju_status_relation,
+        charm=CHARM,
+        relations=RELATIONS,
+        not_exist=[[]],
+        exception=exception,
+    )
+    relation_rule.check()
+    assert relation_rule.missing_relations == expected_missing
+
+
+def test_relation_rule_unknown_charm(mocker, juju_status_relation):
+    """Empty relation for a unknown charm in rules and gives warning message."""
+    charm = "foo_charm"
+    warning_msg = (
+        "Relations rules has an unexpected format. "
+        f"It was not possible to find {charm} on rules"
+    )
+    logger_mock = mocker.patch.object(relations, "LOGGER")
+    relation_rule = relations.RelationRule(
+        charm_to_app=CHARM_TO_APP,
+        applications=juju_status_relation,
+        charm="foo_charm",
+        relations=[["*:public", "keystone:public"]],
+        not_exist=[[]],
+        exception=set(),
+    )
+    assert relation_rule.relations == []
+    logger_mock.warning.assert_has_calls([mocker.call(warning_msg)])
+
+
[e-mail](
+    "fake_relations, app_error, endpoint_error",
+    [
+        ([["foo:juju-info", "bar:juju-info"]], True, False),  # app doesn't exist
+        ([["keystone:bar", "nrpe-host:foo"]], False, True),  # endpoint doesn't exist
+    ],
+)
+def test_relation_rule_unknown_app_endpoint(
+    fake_relations, app_error, endpoint_error, mocker, juju_status_relation
+):
+    """Ensure warning message and empty relations if app or endpoint is unknown."""
+    logger_mock = mocker.patch.object(relations, "LOGGER")
+    app, endpoint = fake_relations[0][0].split(":")
+    if app_error:
+        expected_msg = f"{app} not found on applications to check relations"
+    elif endpoint_error:
+        expected_msg = f"{app} don't have the endpoint: {endpoint} to check relations"
+
+    relations_rule = relations.RelationRule(
+        charm_to_app=CHARM_TO_APP,
+        applications=juju_status_relation,
+        charm=CHARM,
+        relations=fake_relations,
+        not_exist=[[]],
+        exception=set(),
+    )
+    # assert that relations is empty
+    assert relations_rule.relations == []
+    logger_mock.warning.assert_has_calls([mocker.call(expected_msg)])
+
+
+def test_relations_rules_bootstrap(juju_status_relation):
+    """Test RelationsRulesBootStrap object."""
+    charm_to_app = {"nrpe": {"nrpe-host", "nrpe-container"}}
+    relations_rules = [
+        {
+            "charm": "nrpe",
+            "check": [["*:nrpe-external-master", "nrpe:nrpe-external-master"]],
+        },
+        {
+            "charm": "elasticsearch",
+            "check": [
+                ["elasticsearch:nrpe-external-master", "nrpe-host:nrpe-external-master"]
+            ],
+        },
+    ]
+    relations_rules = relations.RelationsRulesBootStrap(
+        charm_to_app=charm_to_app,
+        relations_rules=relations_rules,
+        applications=juju_status_relation,
+    ).check()
+    assert len(relations_rules) == 2
+    assert all(
+        isinstance(relation_rule, relations.RelationRule)
+        for relation_rule in relations_rules
+    )
diff --git a/tox.ini b/tox.ini
index 31ae64d..a89fd0b 100644
--- a/tox.ini
+++ b/tox.ini
@@ -8,7 +8,7 @@ exclude =
     venv,
 max-line-length = 120
 max-complexity = 10
-ignore = D100, D103, C901
+ignore = D100, D103, C901, W503
 
 [tox]
 skipsdist=True