Merge ~martin-kalcok/juju-lint:unit-tests into juju-lint:master

[Martin Kalcok]

Expanded Unit Test coverage.

This change is mostly about adding unit tests. I also made few minor changes to the main codebase
 where it seemed necessary and where it did not change the functionality. I'll add inline comments to any changes to the main code, explaining why I think it should be changed.

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

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

[Gabriel Cocenza (gabrielcocenza)]

Thanks for the effort Martin.

I'll review on parts and those comments are regarding the test_check_spaces module

review: Needs Fixing

[Gabriel Cocenza (gabrielcocenza)]

These comments refers to all other modules with the exception of the logging.py that I'll review tomorrow.

review: Needs Fixing

[Martin Kalcok (martin-kalcok)]

Thanks for your effort Gabriel. I forgot to save my inline comments explaining the few changes I made to the main codebase. I'll add them now, sorry.

[Gabriel Cocenza (gabrielcocenza)]

These are my final comments about the logging.py module.

I also would like to discuss what should we do to force coverage (--cov-fail-under=MIN) on next MRs. IMO, we should consider these two approaches:

1 - Fixing the coverage percentage to what we have right now (95.13) on the tox command for unit tests

2 - add a "# pragma: no cover" on the lines missing unit tests with a message TODO to cover in the future and limit it with 100 percentage.

I slightly prefer the second option.

[Eric Chen (eric-chen)]

LGTM, really good job

There is only small suggestion, please change it, then we can merge it into juju-lint asap.

review: Needs Fixing

[Martin Kalcok (martin-kalcok)]

I updated code according to your comments Erik. Thanks for your review.

I also marked all currently remaining untested code with "#pragma: no cover" and set minimum 100% coverage in tox.ini so that we can require full test coverage on any future PRs.

[Eric Chen (eric-chen)]

A obvious little mistake

review: Needs Fixing

[Gabriel Cocenza (gabrielcocenza)]

I think this PR needs to fix some merge conflicts. Other than that, LGTM.

review: Needs Fixing

[Gabriel Cocenza (gabrielcocenza)]

LGTM, but it's not passing lint test. Once you use "make dev-environment" it will install pre-commit and start catching this kind of issue.

Thanks!

review: Approve

[Eric Chen (eric-chen)]

review: Approve

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

Change successfully merged at revision 3d7a202f2f005c8fc5e9df2e926b6b5001347458

diff --git a/jujulint/check_spaces.py b/jujulint/check_spaces.py
index 975661d..0564508 100644
--- a/jujulint/check_spaces.py
+++ b/jujulint/check_spaces.py
@@ -23,9 +23,7 @@ class Relation:
         While Juju does define separate provider and requirer roles, we'll ignore
         those here.
         """
-        return set([self.endpoint1, self.endpoint2]) == set(
-            [other.endpoint1, other.endpoint2]
-        )
+        return {self.endpoint1, self.endpoint2} == {other.endpoint1, other.endpoint2}
 
     @property
     def endpoints(self):
diff --git a/jujulint/cli.py b/jujulint/cli.py
index 97e5a34..2ea188a 100755
--- a/jujulint/cli.py
+++ b/jujulint/cli.py
@@ -197,5 +197,5 @@ def main():
         cli.usage()
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()
diff --git a/jujulint/cloud.py b/jujulint/cloud.py
index 6d0ec44..490f4d2 100644
--- a/jujulint/cloud.py
+++ b/jujulint/cloud.py
@@ -61,10 +61,9 @@ class Cloud:
         # instance variables
         self.cloud_state = {}
         self.access_method = "local"
-        self.ssh_host = ""
         self.sudo_user = ""
         self.hostname = ""
-        self.name = ""
+        self.name = name
         self.fabric_config = {}
         self.lint_rules = lint_rules
         self.lint_overrides = lint_overrides
@@ -86,7 +85,6 @@ class Cloud:
                 self.access_method = "ssh"
         elif access_method == "local":
             self.hostname = socket.getfqdn()
-        self.name = name
 
     def run_command(self, command):
         """Run a command via fabric on the local or remote host."""
@@ -126,7 +124,8 @@ class Cloud:
     def run_unit_command(self, target, command):
         """Run a command on a Juju unit and return the output."""
 
-    def parse_yaml(self, yaml_string):
+    @staticmethod
+    def parse_yaml(yaml_string):
         """Parse YAML using PyYAML."""
         data = yaml.safe_load_all(yaml_string)
         return list(data)
diff --git a/jujulint/k8s.py b/jujulint/k8s.py
index 53b8c30..9303fe6 100644
--- a/jujulint/k8s.py
+++ b/jujulint/k8s.py
@@ -38,28 +38,18 @@ Todo:
 from jujulint.cloud import Cloud
 
 
-class OpenStack(Cloud):
-    """Helper class for interacting with Nagios via the livestatus socket."""
+class Kubernetes(Cloud):
+    """Specialized subclass of Cloud with helpers related to Kubernetes."""
 
     def __init__(self, *args, **kwargs):
         """Initialise class-local variables and configuration and pass to super."""
-        super(OpenStack, self).__init__(*args, **kwargs)
-
-    def get_neutron_ports(self):
-        """Get a list of neutron ports."""
-
-    def get_neutron_routers(self):
-        """Get a list of neutron routers."""
-
-    def get_neutron_networks(self):
-        """Get a list of neutron networks."""
-
-    def refresh(self):
-        """Refresh cloud information."""
-        return super(OpenStack, self).refresh()
+        super(Kubernetes, self).__init__(*args, **kwargs)
+        self.cloud_type = "kubernetes"
 
     def audit(self):
         """Audit OpenStack cloud and run base Cloud audits."""
-        # add specific OpenStack checks here
-        self.logger.debug("Running OpenStack-specific audit steps.")
-        super(OpenStack, self).audit()
+        # add specific Kubernetes checks here
+        self.logger.info(
+            "[{}] Running Kubernetes-specific audit steps.".format(self.name)
+        )
+        super(Kubernetes, self).audit()
diff --git a/jujulint/lint.py b/jujulint/lint.py
index 8f25617..a931d55 100755
--- a/jujulint/lint.py
+++ b/jujulint/lint.py
@@ -177,12 +177,19 @@ class Linter:
 
         return
 
-    def atoi(self, val):
-        """Deal with complex number representations as strings, returning a number."""
-        if type(val) != str:
-            return val
+    @staticmethod
+    def atoi(val):
+        """Deal with complex number representations as strings.
 
-        if type(val[-1]) != str:
+        This method attempts to convert string containing number and a
+        supported suffix (k,m,g,K,M,G) into a int with appropriate value.
+        e.g.: "2k" -> 2000
+              "2K" -> 2048
+
+        If the input value does not match the expected format, it is returned
+        without the change.
+        """
+        if type(val) != str:
             return val
 
         try:
@@ -190,13 +197,17 @@ class Linter:
         except Exception:
             return val
 
+        suffix = val[-1]
         quotient = 1024
-        if val[-1].lower() == val[-1]:
+        if suffix.islower():
             quotient = 1000
 
         conv = {"g": quotient**3, "m": quotient**2, "k": quotient}
 
-        return _int * conv[val[-1].lower()]
+        if suffix.lower() not in conv:
+            return val
+
+        return _int * conv[suffix.lower()]
 
     def isset(self, name, check_value, rule, config):
         """Check if value is set per rule constraints."""
@@ -293,8 +304,8 @@ class Linter:
 
     def search(self, app_name, check_value, config_key, app_config):
         """Scan through the charm config looking for a match using the regex pattern."""
-        actual_value = app_config.get(config_key)
-        if actual_value:
+        if config_key in app_config:
+            actual_value = app_config.get(config_key)
             if re.search(str(check_value), str(actual_value)):
                 self._log_with_header(
                     "Application {} has a valid config for '{}': regex {} found at {}".format(
@@ -450,7 +461,7 @@ class Linter:
 
             if self.cloud_type == "openstack":
                 # process openstack config rules
-                if "openstack config" in self.lint_rules:
+                if "openstack config" in self.lint_rules:  # pragma: no cover
                     if charm_name in self.lint_rules["openstack config"]:
                         lint_rules.extend(
                             self.lint_rules["openstack config"][charm_name].items()
@@ -464,7 +475,7 @@ class Linter:
                         lint_rules,
                     )
 
-    def check_subs(self, machines_data):
+    def check_subs(self, machines_data):  # pragma: no cover
         """Check the subordinates in the model."""
         all_or_nothing = set()
         for machine in self.model.subs_on_machines:
@@ -790,7 +801,7 @@ class Linter:
                 )
             except Exception:
                 # FOR NOW: super quick and dirty
-                print(
+                self.logger.warn(
                     "Exception caught during space check; please check space by hand. {}".format(
                         traceback.format_exc()
                     )
@@ -1034,7 +1045,7 @@ class Linter:
                         data_d["juju-status"],
                         expected=juju_expected,
                     )
-                else:
+                else:  # pragma: no cover
                     self._log_with_header(
                         "Could not determine Juju status for {}.".format(name),
                         level=logging.WARN,
@@ -1055,7 +1066,7 @@ class Linter:
             )
             for container_name in juju_status["machines"][machine_name].get(
                 "container", []
-            ):
+            ):  # pragma: no cover
                 self.check_status_pair(
                     container_name,
                     "container",
@@ -1117,7 +1128,7 @@ class Linter:
             for unit in applications[app_name]["units"]:
                 machine = applications[app_name]["units"][unit]["machine"]
                 machine = machine.split("/")[0]
-                if machine not in self.model.machines_to_az:
+                if machine not in self.model.machines_to_az:  # pragma: no cover
                     self._log_with_header(
                         "{}: Can't find machine {} in machine to AZ mapping data".format(
                             app_name,
@@ -1164,9 +1175,11 @@ class Linter:
                 parsed_yaml = self.get_main_bundle_doc(parsed_yaml_docs)
                 if parsed_yaml:
                     return self.do_lint(parsed_yaml)
-        self.logger.fubar("Failed to parse YAML from file {}".format(filename))
+        self.logger.fubar(
+            "Failed to parse YAML from file {}".format(filename)
+        )  # pragma: no cover
 
-    def do_lint(self, parsed_yaml):
+    def do_lint(self, parsed_yaml):  # pragma: no cover
         """Lint parsed YAML."""
         # Handle Juju 2 vs Juju 1
         applications = "applications"
@@ -1260,7 +1273,7 @@ class Linter:
             if line.startswith("!include"):
                 try:
                     _, rel_path = line.split()
-                except ValueError:
+                except ValueError:  # pragma: no cover
                     self.logger.warn(
                         "invalid include in rules, ignored: '{}'".format(line)
                     )
diff --git a/jujulint/logging.py b/jujulint/logging.py
index 1d1586d..7ee3e56 100644
--- a/jujulint/logging.py
+++ b/jujulint/logging.py
@@ -49,27 +49,23 @@ class Logger:
             console.setFormatter(colour_formatter)
             self.logger.addHandler(console)
             if logfile:
-                try:
-                    file_logger = colorlog.getLogger("file")
-                    plain_formatter = logging.Formatter(
-                        format_string, datefmt=date_format
-                    )
-                    # If we send output to the file logger specifically, don't propagate it
-                    # to the root logger as well to avoid duplicate output. So if we want
-                    # to only send logging output to the file, you would do this:
-                    #  logging.getLogger('file').info("message for logfile only")
-                    # rather than this:
-                    #  logging.info("message for console and logfile")
-                    file_logger.propagate = False
+                file_logger = colorlog.getLogger("file")
+                plain_formatter = logging.Formatter(format_string, datefmt=date_format)
+                # If we send output to the file logger specifically, don't propagate it
+                # to the root logger as well to avoid duplicate output. So if we want
+                # to only send logging output to the file, you would do this:
+                #  logging.getLogger('file').info("message for logfile only")
+                # rather than this:
+                #  logging.info("message for console and logfile")
+                file_logger.propagate = False
 
-                    file_handler = logging.FileHandler(logfile)
-                    file_handler.setFormatter(plain_formatter)
-                    self.logger.addHandler(file_handler)
-                    file_logger.addHandler(file_handler)
-                except IOError:
-                    logging.error("Unable to write to logfile: {}".format(logfile))
+                file_handler = logging.FileHandler(logfile)
+                file_handler.setFormatter(plain_formatter)
+                self.logger.addHandler(file_handler)
+                file_logger.addHandler(file_handler)
 
-    def fubar(self, msg, exit_code=1):
+    @staticmethod
+    def fubar(msg, exit_code=1):
         """Exit and print to stderr because everything is FUBAR."""
         sys.stderr.write("E: %s\n" % (msg))
         sys.exit(exit_code)
diff --git a/jujulint/openstack.py b/jujulint/openstack.py
index 398721e..5a87252 100644
--- a/jujulint/openstack.py
+++ b/jujulint/openstack.py
@@ -42,7 +42,7 @@ from jujulint.cloud import Cloud
 
 
 class OpenStack(Cloud):
-    """Helper class for interacting with Nagios via the livestatus socket."""
+    """Specialized subclass of Cloud with helpers related to OpenStack."""
 
     def __init__(self, *args, **kwargs):
         """Initialise class-local variables and configuration and pass to super."""
@@ -58,10 +58,6 @@ class OpenStack(Cloud):
     def get_neutron_networks(self):
         """Get a list of neutron networks."""
 
-    def refresh(self):
-        """Refresh cloud information."""
-        return super(OpenStack, self).refresh()
-
     def audit(self):
         """Audit OpenStack cloud and run base Cloud audits."""
         # add specific OpenStack checks here
diff --git a/tests/conftest.py b/tests/conftest.py
index b43a273..d82193d 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -19,6 +19,8 @@ import pytest
 test_path = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, test_path + "/../")
 
+from jujulint import cloud  # noqa: E402
+
 
 @pytest.fixture
 def mocked_pkg_resources(monkeypatch):
@@ -29,7 +31,7 @@ def mocked_pkg_resources(monkeypatch):
 
 
 @pytest.fixture
-def cli(monkeypatch):
+def cli_instance(monkeypatch):
     """Provide a test instance of the CLI class."""
     monkeypatch.setattr(
         sys, "argv", ["juju-lint", "-c", "contrib/canonical-rules.yaml"]
@@ -77,7 +79,7 @@ def linter(parser):
 
 
 @pytest.fixture
-def cloud():
+def cloud_instance():
     """Provide a Cloud instance to test."""
     from jujulint.cloud import Cloud
 
@@ -210,3 +212,11 @@ def juju_export_bundle():
             }
         ],
     }
+
+
[e-mail]()
+def patch_cloud_init(mocker):
+    """Patch objects needed in Cloud.__init__() method."""
+    mocker.patch.object(cloud, "Logger")
+    mocker.patch.object(cloud, "Connection")
+    mocker.patch.object(cloud.socket, "getfqdn", return_value="localhost")
diff --git a/tests/requirements.txt b/tests/requirements.txt
index d31d3fb..ce434c0 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,14 +1,13 @@
 # Module requirements
 black
 colorama
-flake8
+flake8<5.0  # some flake8 plugins seem to be currently broken with version 5.0+
 flake8-colors
 flake8-docstrings
 flake8-html
 isort
 mock
 pep8-naming
-pycodestyle
 pyflakes
 pytest
 pytest-cov
diff --git a/tests/test_check_spaces.py b/tests/test_check_spaces.py
new file mode 100644
index 0000000..9b77e66
--- /dev/null
+++ b/tests/test_check_spaces.py
@@ -0,0 +1,347 @@
+"""Tests for check_spaces.py module."""
+from unittest.mock import call
+
+import pytest
+
+from jujulint import check_spaces
+
+
+def test_relation_init():
+    """Test initiation of Relation instance."""
+    ep_1 = "Endpoint 1"
+    ep_2 = "Endpoint 2"
+
+    relation = check_spaces.Relation(ep_1, ep_2)
+
+    assert relation.endpoint1 == ep_1
+    assert relation.endpoint2 == ep_2
+
+
+def test_relation_str():
+    """Test expected string representation of a Relation class."""
+    ep_1 = "Endpoint 1"
+    ep_2 = "Endpoint 2"
+    expected_str = "Relation({} - {})".format(ep_1, ep_2)
+
+    relation = check_spaces.Relation(ep_1, ep_2)
+
+    assert str(relation) == expected_str
+
+
[e-mail](
+    "rel_1_ep_1, rel_1_ep_2, rel_2_ep_1, rel_2_ep_2, expected_result",
+    [
+        (
+            "same endpoint 1",
+            "same endpoint 2",
+            "same endpoint 1",
+            "same endpoint 2",
+            True,
+        ),
+        (
+            "same endpoint 1",
+            "same endpoint 2",
+            "same endpoint 1",
+            "different endpoint 2",
+            False,
+        ),
+        (
+            "same endpoint 1",
+            "same endpoint 2",
+            "different endpoint 1",
+            "different endpoint 2",
+            False,
+        ),
+        (
+            "same endpoint 1",
+            "same endpoint 2",
+            "different endpoint 1",
+            "same endpoint 2",
+            False,
+        ),
+    ],
+)
+def test_relation_eq(rel_1_ep_1, rel_1_ep_2, rel_2_ep_1, rel_2_ep_2, expected_result):
+    """Test equality operator of Relation class. Only return true if both endpoints match."""
+    relation_1 = check_spaces.Relation(rel_1_ep_1, rel_1_ep_2)
+    relation_2 = check_spaces.Relation(rel_2_ep_1, rel_2_ep_2)
+
+    assert (relation_1 == relation_2) == expected_result
+
+
+def test_relation_endpoints_prop():
+    """Test "endpoints" property of a Relation class."""
+    ep_1 = "Endpoint 1"
+    ep_2 = "Endpoint 2"
+
+    relation = check_spaces.Relation(ep_1, ep_2)
+
+    assert relation.endpoints == [ep_1, ep_2]
+
+
[e-mail](
+    "input_order, output_order",
+    [
+        # Input endpoints are already in alphabetical order, output unchanged
+        (
+            ["A EP", "A Space", "Z EP", "Z Space"],
+            ["A EP", "A Space", "Z EP", "Z Space"],
+        ),
+        # Input endpoints are not in order, output is alphabetically reordered
+        (
+            ["Z EP", "Z Space", "A EP", "A Space"],
+            ["A EP", "A Space", "Z EP", "Z Space"],
+        ),
+        # Input endpoints are the same, no reordering occurs on output
+        (
+            ["Z EP", "A Space", "Z EP", "Z Space"],
+            ["Z EP", "A Space", "Z EP", "Z Space"],
+        ),
+    ],
+)
+def test_space_mismatch_init(input_order, output_order):
+    """Test initiation of SpaceMismatch class.
+
+    This test also verifies that spaces in SpaceMismatch instance are ordered
+    alphabetically based on the endpoint name.
+    """
+    mismatch_instance = check_spaces.SpaceMismatch(*input_order)
+
+    # Assert that endpoints are alphabetically reordered
+    assert mismatch_instance.endpoint1 == output_order[0]
+    assert mismatch_instance.space1 == output_order[1]
+    assert mismatch_instance.endpoint2 == output_order[2]
+    assert mismatch_instance.space2 == output_order[3]
+
+
+def test_space_mismatch_str():
+    """Test string representation of a SpaceMismatch class."""
+    ep_1 = "Endpoint 1"
+    ep_2 = "Endpoint 2"
+    space_1 = "Space 1"
+    space_2 = "Space 2"
+    expected_str = "SpaceMismatch({} (space {}) != {} (space {}))".format(
+        ep_1, space_1, ep_2, space_2
+    )
+
+    mismatch_instance = check_spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
+
+    assert str(mismatch_instance) == expected_str
+
+
+def test_space_mismatch_relation_prop():
+    """Test relation property of a SpaceMismatch class."""
+    ep_1 = "Endpoint 1"
+    ep_2 = "Endpoint 2"
+    space_1 = "Space 1"
+    space_2 = "Space 2"
+
+    expected_relation = check_spaces.Relation(ep_1, ep_2)
+
+    mismatch_instance = check_spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
+
+    assert mismatch_instance.relation == expected_relation
+
+
+def test_space_mismatch_get_charm_relation():
+    """Test get_charm_relation method of SpaceMismatch."""
+    app_1 = "ubuntu_server"
+    charm_1 = "ubuntu"
+    app_2 = "ubuntu_nrpe"
+    charm_2 = "nrpe"
+    ep_1 = app_1 + ":endpoint_1"
+    ep_2 = app_2 + ":endpoint_2"
+    space_1 = "Space 1"
+    space_2 = "Space 2"
+
+    app_map = {app_1: charm_1, app_2: charm_2}
+
+    expected_relation = check_spaces.Relation("ubuntu:endpoint_1", "nrpe:endpoint_2")
+
+    mismatch_instance = check_spaces.SpaceMismatch(ep_1, space_1, ep_2, space_2)
+
+    assert mismatch_instance.get_charm_relation(app_map) == expected_relation
+
+
[e-mail]("use_cmr", [True, False])
+def test_find_space_mismatches(use_cmr, mocker):
+    """Test function find_space_mismatches()."""
+    sample_yaml = "sample yaml"
+    app_1 = "ubuntu_server"
+    app_2 = "ubuntu_nrpe"
+    space_1 = "space 1"
+    space_2 = "space 2"
+    app_endpoint_1 = app_1 + ":endpoint"
+    app_endpoint_2 = app_2 + ":endpoint"
+    relation = check_spaces.Relation(
+        app_endpoint_1, "XModel" if use_cmr else app_endpoint_2
+    )
+    app_list = [app_1, app_2]
+    app_spaces = {app_1: {space_1: "foo"}, app_2: {space_2: "bar"}}
+
+    app_list_mock = mocker.patch.object(
+        check_spaces, "get_juju_applications", return_value=app_list
+    )
+    app_spaces_mock = mocker.patch.object(
+        check_spaces, "get_application_spaces", return_value=app_spaces
+    )
+    rel_list_mock = mocker.patch.object(
+        check_spaces, "get_application_relations", return_value=[relation]
+    )
+    rel_space_mock = mocker.patch.object(
+        check_spaces, "get_relation_space", side_effect=[space_1, space_2]
+    )
+
+    expected_mismatch = [
+        check_spaces.SpaceMismatch(
+            relation.endpoint1, space_1, relation.endpoint2, space_2
+        )
+    ]
+
+    mismatch = check_spaces.find_space_mismatches(sample_yaml, True)
+    result_pairs = zip(expected_mismatch, mismatch)
+
+    app_list_mock.assert_called_once_with(sample_yaml)
+    app_spaces_mock.assert_called_once_with(app_list, sample_yaml)
+    rel_list_mock.assert_called_once_with(sample_yaml)
+    rel_space_mock.assert_has_calls(
+        [
+            call(relation.endpoint1, app_spaces),
+            call(relation.endpoint2, app_spaces),
+        ]
+    )
+    for expected_result, actual_result in result_pairs:
+        assert str(expected_result) == str(actual_result)
+
+
+def test_get_juju_applications():
+    """Test parsing applications from yaml status."""
+    app_1 = "ubuntu"
+    app_2 = "nrpe"
+    sample_yaml = {
+        "applications": {app_1: {"charm-url": "ch:foo"}, app_2: {"charm-url": "ch:bar"}}
+    }
+
+    expected_apps = [app_1, app_2]
+
+    apps = check_spaces.get_juju_applications(sample_yaml)
+
+    assert apps == expected_apps
+
+
+def test_get_application_spaces(mocker):
+    """Test function that returns map of applications and their bindings.
+
+    This test also verifies that default binding to space "alpha" is added to applications
+    that do not specify any bindings.
+    """
+    logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+    default_binding = ""
+    default_space = "custom_default_space"
+    public_binding = "public"
+    public_space = "public_space"
+    app_list = ["ubuntu", "nrpe", "mysql"]
+    sample_yaml = {
+        "applications": {
+            # App with proper bindings
+            app_list[0]: {
+                "bindings": {
+                    default_binding: default_space,
+                    public_binding: public_space,
+                }
+            },
+            # App with missing default bindings
+            app_list[1]: {
+                "bindings": {
+                    public_binding: public_space,
+                }
+            },
+            # App without any bindings defined
+            app_list[2]: {},
+        }
+    }
+
+    expected_app_spaces = {
+        app_list[0]: {default_binding: default_space, public_binding: public_space},
+        app_list[1]: {
+            public_binding: public_space,
+        },
+        app_list[2]: {default_binding: "alpha"},
+    }
+
+    app_spaces = check_spaces.get_application_spaces(app_list, sample_yaml)
+
+    # Verify that all the bindings for properly defined app were returned
+    # Verify that default binding was added to app that did not have any bindings defined
+    # Verify that Warning was logged for app without explicit default binding
+    # Verify that Warnings were logged for app without any bindings
+
+    assert app_spaces == expected_app_spaces
+    logger_mock.warning.assert_has_calls(
+        [
+            call(
+                "Application %s does not define explicit default binding", app_list[1]
+            ),
+            call("Application %s is missing explicit bindings", app_list[2]),
+            call("Setting default binding of '%s' to alpha", app_list[2]),
+        ]
+    )
+
+
+def test_get_application_relations():
+    """Test function that returns list of relations."""
+    sample_yaml = {
+        "relations": [
+            ["ubuntu:juju-info", "nrpe:general-info"],
+            ["vault:shared-db", "mysql-innodb-cluster:shared-db"],
+        ]
+    }
+
+    expected_relations = [
+        check_spaces.Relation("ubuntu:juju-info", "nrpe:general-info"),
+        check_spaces.Relation("vault:shared-db", "mysql-innodb-cluster:shared-db"),
+    ]
+
+    relations = check_spaces.get_application_relations(sample_yaml)
+
+    assert relations == expected_relations
+
+
[e-mail]("use_explicit_binding", [True, False])
+def test_get_relation_space(use_explicit_binding):
+    """Test getting space for a specific binding."""
+    app_name = "ubuntu"
+    interface = "juju_info"
+    default_space = "alpha"
+    endpoint = app_name + ":" + interface
+
+    app_spaces = {"ubuntu": {"": default_space}}
+
+    if use_explicit_binding:
+        expected_space = "custom_space"
+        app_spaces["ubuntu"][interface] = expected_space
+    else:
+        expected_space = default_space
+
+    space = check_spaces.get_relation_space(endpoint, app_spaces)
+
+    assert space == expected_space
+
+
+def test_get_relation_space_cmr(mocker):
+    """Test getting space for cross model relation."""
+    logger_mock = mocker.patch.object(check_spaces, "LOGGER")
+    app_name = "ubuntu"
+    interface = "juju_info"
+    endpoint = app_name + ":" + interface
+
+    app_spaces = {}
+
+    space = check_spaces.get_relation_space(endpoint, app_spaces)
+
+    assert space == "XModel"
+    logger_mock.warning.assert_called_once_with(
+        "Multi-model is not supported yet. Please check "
+        "if '%s' is from another model",
+        app_name,
+    )
diff --git a/tests/test_cli.py b/tests/test_cli.py
index c5a9e95..ed63f67 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -1,7 +1,11 @@
 #!/usr/bin/python3
 """Test the CLI."""
+from logging import WARN
+from unittest.mock import MagicMock, call
 
-from jujulint.cli import Cli
+import pytest
+
+from jujulint import cli
 
 
 def test_pytest():
@@ -9,6 +13,376 @@ def test_pytest():
     assert True
 
 
-def test_cli_fixture(cli):
+def test_cli_fixture(cli_instance):
     """Test if the CLI fixture works."""
-    assert isinstance(cli, Cli)
+    assert isinstance(cli_instance, cli.Cli)
+
+
[e-mail]("output_format_value", ["text", "json"])
+def test_cli_init(output_format_value, mocker):
+    """Test initiation of CLI class."""
+    logging_mock = mocker.patch.object(cli, "logging")
+
+    loglevel_value = "warn"
+    loglevel = MagicMock()
+    loglevel.get.return_value = loglevel_value
+
+    output_format = MagicMock()
+    output_format.get.return_value = output_format_value
+
+    rules_file_value = "/tmp/rules.yaml"
+    rules_file = MagicMock()
+    rules_file.get.return_value = rules_file_value
+
+    config = {
+        "logging": {"loglevel": loglevel},
+        "format": output_format,
+        "rules": {"file": rules_file},
+    }
+
+    mocker.patch.object(cli, "Config", return_value=config)
+    mocker.patch.object(cli.os.path, "isfile", return_value=True)
+
+    cli_instance = cli.Cli()
+
+    assert cli_instance.logger.logger.level == WARN
+    assert cli_instance.output_format == output_format_value
+    assert cli_instance.lint_rules == rules_file_value
+
+    if output_format_value != "text":
+        logging_mock.disable.assert_called_once_with(level=logging_mock.CRITICAL)
+
+
[e-mail]("version", ["1.0", None])
+def test_cli_ini_version(version, mocker):
+    """Test detection of juju-lint version on Cli init."""
+    require_rvalue = MagicMock()
+    require_rvalue.version = version
+    mocker.patch.object(cli, "Config")
+
+    if version:
+        require_mock = mocker.patch.object(
+            cli.pkg_resources, "require", return_value=[require_rvalue]
+        )
+    else:
+        require_mock = mocker.patch.object(
+            cli.pkg_resources,
+            "require",
+            side_effect=cli.pkg_resources.DistributionNotFound,
+        )
+
+    expected_version = version or "unknown"
+
+    cli_instance = cli.Cli()
+
+    require_mock.assert_called_once_with("jujulint")
+    assert cli_instance.version == expected_version
+
+
[e-mail]("rules_path", ["absolute", "relative", None])
+def test_cli_init_rules_path(rules_path, mocker):
+    """Test different methods of loading rules file on Cli init.
+
+    methods:
+      * via absolut path
+      * via path relative to config dir
+      * rules file could not be found
+    """
+    config_dir = "/tmp/foo"
+    file_path = "rules.yaml"
+    rule_file = MagicMock()
+    rule_file.get.return_value = file_path
+
+    config_dict = {
+        "logging": {"loglevel": MagicMock()},
+        "format": MagicMock(),
+        "rules": {"file": rule_file},
+    }
+    config = MagicMock()
+    config.__getitem__.side_effect = config_dict.__getitem__
+    config.config_dir.return_value = config_dir
+    mocker.patch.object(cli, "Config", return_value=config)
+    exit_mock = mocker.patch.object(cli.sys, "exit")
+
+    if rules_path == "absolute":
+        mocker.patch.object(cli.os.path, "isfile", return_value=True)
+    elif rules_path == "relative":
+        mocker.patch.object(cli.os.path, "isfile", side_effect=[False, True])
+    else:
+        mocker.patch.object(cli.os.path, "isfile", return_value=False)
+
+    cli_instance = cli.Cli()
+
+    if rules_path == "absolute":
+        assert cli_instance.lint_rules == file_path
+        exit_mock.assert_not_called()
+    elif rules_path == "relative":
+        assert cli_instance.lint_rules == "{}/{}".format(config_dir, file_path)
+        exit_mock.assert_not_called()
+    else:
+        exit_mock.assert_called_once_with(1)
+
+
[e-mail]("is_cloud_set", [True, False])
+def test_cli_cloud_type(cli_instance, is_cloud_set):
+    """Test cloud_type() property of Cli class."""
+    cloud_type_value = "openstack"
+    cloud_type = MagicMock()
+    cloud_type.get.return_value = cloud_type_value
+
+    config = {"cloud-type": cloud_type} if is_cloud_set else {}
+    cli_instance.config = config
+
+    if is_cloud_set:
+        assert cli_instance.cloud_type == cloud_type_value
+    else:
+        assert cli_instance.cloud_type is None
+
+
[e-mail]("is_file_set", [True, False])
+def test_cli_manual_file(cli_instance, is_file_set):
+    """Test manual_file() property of Cli class."""
+    manual_file_value = "./rules.yaml"
+    manual_file = MagicMock()
+    manual_file.get.return_value = manual_file_value
+
+    config = {"manual-file": manual_file} if is_file_set else {}
+    cli_instance.config = config
+
+    if is_file_set:
+        assert cli_instance.manual_file == manual_file_value
+    else:
+        assert cli_instance.manual_file is None
+
+
[e-mail](
+    "cloud_type_value, manual_file_value",
+    [
+        ("openstack", "rules.yaml"),
+        (None, None),
+    ],
+)
+def test_cli_startup_message(cli_instance, cloud_type_value, manual_file_value, mocker):
+    """Test output of a startup message."""
+    version = "1.0"
+    config_dir = "/tmp/"
+    lint_rules = "some rules"
+
+    log_level_value = "debug"
+    log_level = MagicMock()
+    log_level.get.return_value = log_level_value
+
+    cloud_type = MagicMock()
+    cloud_type.get.return_value = cloud_type_value
+
+    manual_file = MagicMock()
+    manual_file.get.return_value = manual_file_value
+
+    config_data = {
+        "logging": {"loglevel": log_level},
+        "cloud-type": cloud_type,
+        "manual-file": manual_file,
+    }
+
+    config = MagicMock()
+    config.config_dir.return_value = config_dir
+    config.__getitem__.side_effect = config_data.__getitem__
+    config.__contains__.side_effect = config_data.__contains__
+
+    expected_msg = (
+        "juju-lint version {} starting...\n\t* Config directory: {}\n"
+        "\t* Cloud type: {}\n\t* Manual file: {}\n\t* Rules file: {}\n"
+        "\t* Log level: {}\n"
+    ).format(
+        version,
+        config_dir,
+        cloud_type_value or "Unknown",
+        manual_file_value or False,
+        lint_rules,
+        log_level_value,
+    )
+
+    cli_instance.version = version
+    cli_instance.config = config
+    cli_instance.lint_rules = lint_rules
+    log_mock = mocker.patch.object(cli_instance, "logger")
+
+    assert cli_instance.cloud_type == cloud_type_value
+    cli_instance.startup_message()
+
+    log_mock.info.assert_called_once_with(expected_msg)
+
+
+def test_cli_usage(cli_instance):
+    """Test usage() method of Cli class."""
+    config_mock = MagicMock()
+    cli_instance.config = config_mock
+
+    cli_instance.usage()
+
+    config_mock.parser.print_help.assert_called_once()
+
+
+def test_cli_audit_file(cli_instance, mocker):
+    """Test method audit_file() from Cli class."""
+    filename = "/tmp/bundle.yaml"
+    rules = "/tmp/rules.yaml"
+    cloud_type = "openstack"
+    output_format = "text"
+    linter_object = MagicMock()
+
+    mock_linter = mocker.patch.object(cli, "Linter", return_value=linter_object)
+    cli_instance.lint_rules = rules
+    cli_instance.output_format = output_format
+
+    cli_instance.audit_file(filename, cloud_type)
+
+    mock_linter.assert_called_once_with(
+        filename, rules, cloud_type=cloud_type, output_format=output_format
+    )
+    linter_object.read_rules.assert_called_once()
+    linter_object.lint_yaml_file.assert_called_once_with(filename)
+
+
+def test_cli_audit_all(cli_instance, mocker):
+    """Test audit_all() method from Cli class."""
+    audit_mock = mocker.patch.object(cli_instance, "audit")
+    write_yaml_mock = mocker.patch.object(cli_instance, "write_yaml")
+
+    cloud_data = "cloud data"
+    clouds_value = ["cloud_1", "cloud_2"]
+    clouds = MagicMock()
+    clouds.get.return_value = clouds_value
+
+    config_data = {"clouds": clouds}
+    config = MagicMock()
+    config.__getitem__.side_effect = config_data.__getitem__
+
+    cli_instance.clouds = cloud_data
+    cli_instance.config = config
+
+    cli_instance.audit_all()
+
+    audit_mock.assert_has_calls([call(cloud) for cloud in clouds_value])
+    write_yaml_mock.assert_called_once_with(cloud_data, "all-data.yaml")
+
+
[e-mail]("success", [True, False])
+def test_cli_audit(cli_instance, success, mocker):
+    """Test audit() method from Cli class."""
+    cloud_name = "test cloud"
+    lint_rules = "rules.yaml"
+    cloud_data = {
+        "access": "ssh",
+        "sudo": "root",
+        "host": "juju.host",
+        "type": "openstack",
+    }
+
+    cloud = MagicMock()
+    cloud.get.return_value = cloud_data
+
+    config_data = {"clouds": {cloud_name: cloud}}
+
+    cloud_state = {"key": "value"}
+    mock_openstack_instance = MagicMock()
+    mock_openstack_instance.refresh.return_value = success
+    mock_openstack_instance.cloud_state = cloud_state
+    mock_openstack = mocker.patch.object(
+        cli, "OpenStack", return_value=mock_openstack_instance
+    )
+
+    mock_yaml = mocker.patch.object(cli_instance, "write_yaml")
+
+    mock_logger = MagicMock()
+    cli_instance.logger = mock_logger
+
+    cli_instance.config = config_data
+    cli_instance.lint_rules = lint_rules
+
+    # assert cli_instance.config["clouds"]
+    cli_instance.audit(cloud_name=cloud_name)
+
+    mock_openstack.assert_called_once_with(
+        cloud_name,
+        access_method=cloud_data["access"],
+        ssh_host=cloud_data["host"],
+        sudo_user=cloud_data["sudo"],
+        lint_rules=lint_rules,
+    )
+
+    if success:
+        assert cli_instance.clouds[cloud_name] == cloud_state
+        mock_yaml.assert_called_once_with(
+            cloud_state, "{}-state.yaml".format(cloud_name)
+        )
+        mock_openstack_instance.audit.assert_called_once()
+    else:
+        mock_logger.error.assert_called_once_with(
+            "[{}] Failed getting cloud state".format(cloud_name)
+        )
+
+
+def test_cli_write_yaml(cli_instance, mocker):
+    """Test write_yaml() method from Cli class."""
+    yaml_mock = mocker.patch.object(cli, "yaml")
+    data = "{'yaml': 'data'}"
+    file_name = "dump.yaml"
+
+    output_folder_value = "/tmp"
+    output_folder = MagicMock()
+    output_folder.get.return_value = output_folder_value
+
+    opened_file = MagicMock()
+    mock_open = mocker.patch("builtins.open", return_value=opened_file)
+
+    config = {"output": {"dump": True, "folder": output_folder}}
+
+    cli_instance.config = config
+    cli_instance.write_yaml(data, file_name)
+
+    mock_open.assert_called_once_with(
+        "{}/{}".format(output_folder_value, file_name), "w"
+    )
+    yaml_mock.dump.assert_called_once_with(data, opened_file)
+
+
[e-mail]("audit_type", ["file", "all", None])
+def test_main(cli_instance, audit_type, mocker):
+    """Test main entrypoint of jujulint."""
+    mocker.patch.object(cli_instance, "startup_message")
+    mocker.patch.object(cli_instance, "usage")
+    mocker.patch.object(cli_instance, "audit_file")
+    mocker.patch.object(cli_instance, "audit_all")
+
+    manual_file_value = "bundle.yaml"
+    manual_file = MagicMock()
+    manual_file.get.return_value = manual_file_value
+
+    cloud_type_value = "openstack"
+    cloud_type = MagicMock()
+    cloud_type.get.return_value = cloud_type_value
+
+    cli_instance.config = {"cloud-type": cloud_type}
+
+    if audit_type == "file":
+        cli_instance.config["manual-file"] = manual_file
+    elif audit_type == "all":
+        cli_instance.config["clouds"] = ["cloud_1", "cloud_2"]
+
+    mocker.patch.object(cli, "Cli", return_value=cli_instance)
+
+    cli.main()
+
+    if audit_type == "file":
+        cli_instance.audit_file.assert_called_once_with(
+            manual_file_value, cloud_type=cloud_type_value
+        )
+        cli_instance.audit_all.assert_not_called()
+    elif audit_type == "all":
+        cli_instance.audit_all.assert_called_once()
+        cli_instance.audit_file.assert_not_called()
+    else:
+        cli_instance.usage.assert_called_once()
+        cli_instance.audit_all.assert_not_called()
+        cli_instance.audit_file.assert_not_called()
diff --git a/tests/test_cloud.py b/tests/test_cloud.py
index 885f319..a3ba423 100644
--- a/tests/test_cloud.py
+++ b/tests/test_cloud.py
@@ -1,129 +1,512 @@
 #!/usr/bin/python3
-"""Tests for Cloud."""
+"""Tests for cloud.py module."""
 from subprocess import CalledProcessError
-from unittest.mock import call, patch
+from unittest.mock import MagicMock, call, patch
 
+import pytest
 
-class TestCloud:
-    """Test the main Cloud class."""
+from jujulint import cloud
 
-    @patch("jujulint.cloud.check_output")
-    def test_get_bundle_no_apps(self, mock_check_out, cloud):
-        """Models with no apps raises CalledProcessError to export bundle."""
-        cmd = ["juju", "export-bundle", "-m", "my_controller:controller"]
-        e = CalledProcessError(1, cmd)
-        mock_check_out.side_effect = e
-        cloud.get_juju_bundle("my_controller", "controller")
-        expected_error_msg = call.error(e)
 
-        expected_warn_msg = call.warn(
-            (
-                "An error happened to get the bundle on my_controller:controller. "
-                "If the model doesn't have apps, disconsider this message."
-            )
+@patch("jujulint.cloud.check_output")
+def test_get_bundle_no_apps(mock_check_out, cloud_instance):
+    """Models with no apps raises CalledProcessError to export bundle."""
+    cmd = ["juju", "export-bundle", "-m", "my_controller:controller"]
+    e = CalledProcessError(1, cmd)
+    mock_check_out.side_effect = e
+    cloud_instance.get_juju_bundle("my_controller", "controller")
+    expected_error_msg = call.error(e)
+
+    expected_warn_msg = call.warn(
+        (
+            "An error happened to get the bundle on my_controller:controller. "
+            "If the model doesn't have apps, disconsider this message."
         )
-        assert expected_error_msg in cloud.logger.method_calls
-        assert expected_warn_msg in cloud.logger.method_calls
-
-    @patch("jujulint.cloud.Cloud.parse_yaml")
-    @patch("jujulint.cloud.Cloud.run_command")
-    def test_get_bundle_offer_side(
-        self, mock_run, mock_parse, cloud, juju_export_bundle
-    ):
-        """Test the bundle generated in the offer side."""
-        # simulate cloud_state with info that came from "get_juju_status"
-        cloud.cloud_state = {
-            "my_controller": {
-                "models": {
-                    "my_model_1": {
-                        "applications": {
-                            "nrpe": {
-                                "charm-origin": "charmhub",
-                                "os": "ubuntu",
-                                "endpoint-bindings": {"": "alpha", "monitors": "alpha"},
-                            }
+    )
+    assert expected_error_msg in cloud_instance.logger.method_calls
+    assert expected_warn_msg in cloud_instance.logger.method_calls
+
+
+@patch("jujulint.cloud.Cloud.parse_yaml")
+@patch("jujulint.cloud.Cloud.run_command")
+def test_get_bundle_offer_side(
+    mock_run, mock_parse, cloud_instance, juju_export_bundle
+):
+    """Test the bundle generated in the offer side."""
+    # simulate cloud_state with info that came from "get_juju_status"
+    cloud_instance.cloud_state = {
+        "my_controller": {
+            "models": {
+                "my_model_1": {
+                    "applications": {
+                        "nrpe": {
+                            "charm-origin": "charmhub",
+                            "os": "ubuntu",
+                            "endpoint-bindings": {"": "alpha", "monitors": "alpha"},
                         }
-                    },
-                    "my_model_2": {},
-                }
+                    }
+                },
+                "my_model_2": {},
             }
         }
-        mock_parse.return_value = juju_export_bundle["my_model_1"]
-        # "offers" field exists inside nrpe because of the overlay bundle.
-        # saas field doesn't exist in the offer side because there is no url.
-        # don't overwrite information that came from "get_juju_status".
-        expected_cloud_state = {
-            "my_controller": {
-                "models": {
-                    "my_model_1": {
-                        "applications": {
-                            "nrpe": {
-                                "charm": "nrpe",
-                                "charm-origin": "charmhub",
-                                "os": "ubuntu",
-                                "endpoint-bindings": {"": "alpha", "monitors": "alpha"},
-                                "channel": "stable",
-                                "revision": 86,
-                                "offers": {
-                                    "nrpe": {
-                                        "endpoints": ["monitors"],
-                                        "acl": {"admin": "admin"},
-                                    }
-                                },
-                            },
-                            "ubuntu": {
-                                "charm": "ubuntu",
-                                "channel": "stable",
-                                "revision": 19,
-                                "num_units": 1,
-                                "to": ["0"],
-                                "constraints": "arch=amd64",
+    }
+    mock_parse.return_value = juju_export_bundle["my_model_1"]
+    # "offers" field exists inside nrpe because of the overlay bundle.
+    # saas field doesn't exist in the offer side because there is no url.
+    # don't overwrite information that came from "get_juju_status".
+    expected_cloud_state = {
+        "my_controller": {
+            "models": {
+                "my_model_1": {
+                    "applications": {
+                        "nrpe": {
+                            "charm": "nrpe",
+                            "charm-origin": "charmhub",
+                            "os": "ubuntu",
+                            "endpoint-bindings": {"": "alpha", "monitors": "alpha"},
+                            "channel": "stable",
+                            "revision": 86,
+                            "offers": {
+                                "nrpe": {
+                                    "endpoints": ["monitors"],
+                                    "acl": {"admin": "admin"},
+                                }
                             },
-                        }
-                    },
-                    "my_model_2": {},
-                }
-            }
-        }
-        cloud.get_juju_bundle("my_controller", "my_model_1")
-        assert mock_run.called_once_with(
-            "juju export-bundle -m my_controller:my_model_1"
-        )
-        assert cloud.cloud_state == expected_cloud_state
-
-    @patch("jujulint.cloud.Cloud.parse_yaml")
-    @patch("jujulint.cloud.Cloud.run_command")
-    def test_get_bundle_consumer_side(
-        self, mock_run, mock_parse, cloud, juju_export_bundle
-    ):
-        """Test the bundle generated in the consumer side."""
-        mock_parse.return_value = juju_export_bundle["my_model_2"]
-        # "offers" field won't exist in the consumer side
-        # saas field exists because the consumer side shows url
-        expected_cloud_state = {
-            "my_controller": {
-                "models": {
-                    "my_model_1": {},
-                    "my_model_2": {
-                        "applications": {
-                            "nagios": {
-                                "charm": "nagios",
-                                "channel": "stable",
-                                "revision": 49,
-                                "num_units": 1,
-                                "to": ["0"],
-                                "constraints": "arch=amd64",
-                            }
                         },
-                        "saas": {
-                            "nrpe": {"url": "my_controller:admin/my_model_1.nrpe"}
+                        "ubuntu": {
+                            "charm": "ubuntu",
+                            "channel": "stable",
+                            "revision": 19,
+                            "num_units": 1,
+                            "to": ["0"],
+                            "constraints": "arch=amd64",
                         },
+                    }
+                },
+                "my_model_2": {},
+            }
+        }
+    }
+    cloud_instance.get_juju_bundle("my_controller", "my_model_1")
+    assert mock_run.called_once_with("juju export-bundle -m my_controller:my_model_1")
+    assert cloud_instance.cloud_state == expected_cloud_state
+
+
+@patch("jujulint.cloud.Cloud.parse_yaml")
+@patch("jujulint.cloud.Cloud.run_command")
+def test_get_bundle_consumer_side(
+    mock_run, mock_parse, cloud_instance, juju_export_bundle
+):
+    """Test the bundle generated in the consumer side."""
+    mock_parse.return_value = juju_export_bundle["my_model_2"]
+    # "offers" field won't exist in the consumer side
+    # saas field exists because the consumer side shows url
+    expected_cloud_state = {
+        "my_controller": {
+            "models": {
+                "my_model_1": {},
+                "my_model_2": {
+                    "applications": {
+                        "nagios": {
+                            "charm": "nagios",
+                            "channel": "stable",
+                            "revision": 49,
+                            "num_units": 1,
+                            "to": ["0"],
+                            "constraints": "arch=amd64",
+                        }
                     },
-                }
+                    "saas": {"nrpe": {"url": "my_controller:admin/my_model_1.nrpe"}},
+                },
             }
         }
-        cloud.get_juju_bundle("my_controller", "my_model_2")
-        assert mock_run.called_once_with(
-            "juju export-bundle -m my_controller:my_model_2"
+    }
+    cloud_instance.get_juju_bundle("my_controller", "my_model_2")
+    assert mock_run.called_once_with("juju export-bundle -m my_controller:my_model_2")
+    assert cloud_instance.cloud_state == expected_cloud_state
+
+
[e-mail](
+    "sudo_user, access_method, ssh_host",
+    [("", "local", ""), ("root", "ssh", "juju.host")],
+)
+def test_cloud_init(sudo_user, access_method, ssh_host, mocker):
+    """Test Cloud class initialization."""
+    logger_mock = MagicMock()
+    mocker.patch.object(cloud, "Logger", return_value=logger_mock)
+    connection_mock = MagicMock()
+    mocker.patch.object(cloud, "Connection", return_value=connection_mock)
+    local_fqdn = "localhost"
+    mocker.patch.object(cloud.socket, "getfqdn", return_value=local_fqdn)
+
+    name = "Foo Cloud"
+    lint_rules = {"Custom": "ruleset"}
+    lint_overrides = {"Override": "rule"}
+    cloud_type = "test"
+
+    cloud_instance = cloud.Cloud(
+        name=name,
+        lint_rules=lint_rules,
+        access_method=access_method,
+        ssh_host=ssh_host,
+        sudo_user=sudo_user,
+        lint_overrides=lint_overrides,
+        cloud_type=cloud_type,
+    )
+
+    assert cloud_instance.cloud_state == {}
+    assert cloud_instance.access_method == access_method
+    assert cloud_instance.sudo_user == sudo_user or ""
+    assert cloud_instance.lint_rules == lint_rules
+    assert cloud_instance.lint_overrides == lint_overrides
+
+    if sudo_user:
+        assert cloud_instance.fabric_config.get("sudo") == {"user": sudo_user}
+    else:
+        assert cloud_instance.fabric_config == {}
+
+    if access_method == "local":
+        assert cloud_instance.hostname == local_fqdn
+        connection_mock.assert_not_called()
+    else:
+        assert cloud_instance.hostname == ssh_host
+        assert cloud_instance.connection == connection_mock
+
+
+def test_run_local_command(patch_cloud_init, mocker):
+    """Test running command when the cloud access method is 'local'."""
+    expected_result = ".\n.."
+    check_output_mock = mocker.patch.object(
+        cloud, "check_output", return_value=expected_result
+    )
+
+    command = "ls -la"
+    command_split = command.split()
+
+    cloud_instance = cloud.Cloud(
+        name="local test cloud", access_method="local", cloud_type="test"
+    )
+    result = cloud_instance.run_command(command)
+
+    # command is executed locally
+    check_output_mock.assert_called_once_with(command_split)
+    assert result == expected_result
+
+
[e-mail]("sudo", [True, False])
+def test_run_remote_command(patch_cloud_init, sudo, mocker):
+    """Test running command when the cloud access method is 'ssh'.
+
+    This test has two variants. Executing commands as regular user
+    and executing them as root.
+    """
+    expected_result = MagicMock()
+    expected_result.stdout = ".\n.."
+
+    executor_method = "sudo" if sudo else "run"
+
+    command = "ls -la"
+
+    cloud_instance = cloud.Cloud(
+        name="remote test cloud",
+        access_method="ssh",
+        ssh_host="juju.host",
+        sudo_user="root" if sudo else "",
+        cloud_type="test",
+    )
+
+    mocker.patch.object(
+        cloud_instance.connection, executor_method, return_value=expected_result
+    )
+
+    result = cloud_instance.run_command(command)
+
+    # command was executed remotely as root
+    if sudo:
+        cloud_instance.connection.sudo.assert_called_once_with(
+            command, hide=True, warn=True
+        )
+    else:
+        cloud_instance.connection.run.assert_called_once_with(
+            command, hide=True, warn=True
+        )
+    assert result == expected_result.stdout
+
+
[e-mail]("sudo", [True, False])
+def test_run_remote_command_fail(patch_cloud_init, sudo, mocker):
+    """Test error logging when remote command fails.
+
+    This test has two variants. Executing commands as regular user
+    and executing them as root.
+    """
+    command = "ls -la"
+    cloud_name = "remote test cloud"
+    executor_method = "sudo" if sudo else "run"
+    exception = cloud.SSHException()
+    expected_message = "[{}] SSH command {} failed: {}".format(
+        cloud_name, command, exception
+    )
+
+    cloud_instance = cloud.Cloud(
+        name=cloud_name,
+        access_method="ssh",
+        ssh_host="juju.host",
+        sudo_user="root" if sudo else "",
+        cloud_type="test",
+    )
+
+    mocker.patch.object(
+        cloud_instance.connection, executor_method, side_effect=exception
+    )
+
+    # reset logger mock to wipe any previous calls
+    cloud_instance.logger.reset_mock()
+
+    result = cloud_instance.run_command(command)
+
+    # remote command failure was logged
+    cloud_instance.logger.error.assert_called_once_with(expected_message)
+    assert result is None
+
+
+def test_yaml_loading():
+    """Test loading yaml documents into list of dictionaries."""
+    yaml_string = "controllers:\n" "  ctrl1:\n" "    current-model: test-model\n"
+    expected_output = [{"controllers": {"ctrl1": {"current-model": "test-model"}}}]
+
+    assert cloud.Cloud.parse_yaml(yaml_string) == expected_output
+
+
[e-mail]("success", [True, False])
+def test_get_juju_controllers(patch_cloud_init, success, mocker):
+    """Test method that retrieves a list of juju controllers.
+
+    This test also verifies behavior in case the command to fetch controllers fails.
+    """
+    controller_name = "foo"
+    controller_config = {
+        "current-model": "default",
+        "user": "admin",
+        "access": "superuser",
+    }
+    controller_list = [{"controllers": {controller_name: controller_config}}]
+
+    mocker.patch.object(cloud.Cloud, "run_command", return_value=success)
+    mocker.patch.object(cloud.Cloud, "parse_yaml", return_value=controller_list)
+
+    cloud_instance = cloud.Cloud(name="Test cloud")
+
+    result = cloud_instance.get_juju_controllers()
+
+    if success:
+        assert result
+        assert (
+            cloud_instance.cloud_state[controller_name]["config"] == controller_config
+        )
+    else:
+        assert not result
+        assert controller_name not in cloud_instance.cloud_state
+        cloud_instance.logger.error.assert_called_once_with(
+            "[{}] Could not get controller list".format(cloud_instance.name)
+        )
+
+
[e-mail]("success", [True, False])
+def test_get_juju_models(patch_cloud_init, success, mocker):
+    """Test methods that retrieves a list of juju models."""
+    model_foo = {"name": "admin/foo", "short-name": "foo", "uuid": "129bd0f0"}
+    model_bar = {"name": "admin/bar", "short-name": "bar", "uuid": "b513b5e3"}
+    model_list = [{"models": [model_foo, model_bar]}] if success else []
+
+    controller_name = "controller_1"
+    controllers = {controller_name: {}} if success else {}
+
+    run_cmd_mock = mocker.patch.object(cloud.Cloud, "run_command", return_value=success)
+    mocker.patch.object(cloud.Cloud, "parse_yaml", return_value=model_list)
+    mocker.patch.object(cloud.Cloud, "get_juju_controllers", return_value=controllers)
+
+    cloud_instance = cloud.Cloud(name="Test cloud")
+    cloud_instance.cloud_state = controllers
+
+    result = cloud_instance.get_juju_models()
+
+    if success:
+        assert result
+        run_cmd_mock.assert_called_once_with(
+            "juju models -c {} --format yaml".format(controller_name)
         )
-        assert cloud.cloud_state == expected_cloud_state
+        for model in [model_foo, model_bar]:
+            model_name = model["short-name"]
+            model_config = cloud_instance.cloud_state[controller_name]["models"][
+                model_name
+            ]["config"]
+            assert model_config == model
+    else:
+        assert not result
+        for model in [model_foo, model_bar]:
+            model_name = model["short-name"]
+            assert model_name not in cloud_instance.cloud_state.get(
+                controller_name, {}
+            ).get("models", {})
+
+
[e-mail]("success", [True, False])
+def test_get_juju_state(cloud_instance, success, mocker):
+    """Test function "get_juju_state" that updates local juju state."""
+    controller_foo = {
+        "models": {"foo_1": "foo_1_model_data", "foo_2": "foo_2_model_data"}
+    }
+    controller_bar = {
+        "models": {"bar_1": "bar_1_model_data", "bar_2": "bar_2_model_data"}
+    }
+    cloud_state = {"controller_foo": controller_foo, "controller_bar": controller_bar}
+
+    expected_calls = [
+        call("controller_foo", "foo_1"),
+        call("controller_foo", "foo_2"),
+        call("controller_bar", "bar_1"),
+        call("controller_bar", "bar_2"),
+    ]
+
+    mocker.patch.object(cloud_instance, "get_juju_models", return_value=success)
+    get_status_mock = mocker.patch.object(cloud_instance, "get_juju_status")
+    get_bundle_mock = mocker.patch.object(cloud_instance, "get_juju_bundle")
+
+    cloud_instance.cloud_state = cloud_state
+
+    result = cloud_instance.get_juju_state()
+
+    if success:
+        assert result
+        get_status_mock.assert_has_calls(expected_calls)
+        get_bundle_mock.assert_has_calls(expected_calls)
+    else:
+        assert not result
+        get_status_mock.assert_not_called()
+        get_bundle_mock.assert_not_called()
+
+
+def test_get_juju_status(cloud_instance, mocker):
+    """Test updating status of a selected model."""
+    model_version = "1"
+    model_name = "foo model"
+    controller_name = "foo controller"
+    machine_1_implicit_name = "1"
+    machine_2_implicit_name = "2"
+    machine_2_explicit_name = "explicit_machine - 2"
+    cmd_output_mock = "foo data"
+    model_status = {
+        "model": {"version": model_version},
+        "machines": {
+            machine_1_implicit_name: {"arch": "x86"},
+            machine_2_implicit_name: {
+                "arch": "armv7",
+                "display-name": machine_2_explicit_name,
+            },
+        },
+        "applications": {
+            "ubuntu": {"application-status": {"current": "ready"}},
+            "ntp": {"application-status": {"current": "waiting"}},
+        },
+    }
+
+    run_cmd_mock = mocker.patch.object(
+        cloud_instance, "run_command", return_value=cmd_output_mock
+    )
+    mocker.patch.object(cloud_instance, "parse_yaml", return_value=[model_status])
+
+    cloud_instance.cloud_state = {controller_name: {"models": {model_name: {}}}}
+
+    cloud_instance.get_juju_status(controller_name, model_name)
+
+    # assert that correct command was called
+    run_cmd_mock.assert_called_with(
+        "juju status -m {}:{} --format yaml".format(controller_name, model_name)
+    )
+
+    model_data = cloud_instance.cloud_state[controller_name]["models"][model_name]
+    # assert that application data was loaded to the model
+    assert model_data["applications"] == model_status["applications"]
+    # assert that both implicitly and explicitly named machines are loaded in the model
+    expected_machines = {
+        machine_1_implicit_name: {"arch": "x86", "machine_id": machine_1_implicit_name},
+        machine_2_explicit_name: {
+            "arch": "armv7",
+            "display-name": machine_2_explicit_name,
+            "machine_id": machine_2_implicit_name,
+        },
+    }
+    assert model_data["machines"] == expected_machines
+
+
+def test_refresh(cloud_instance, mocker):
+    """Test refresh method."""
+    expected_result = True
+    get_state_mock = mocker.patch.object(
+        cloud_instance, "get_juju_state", return_value=expected_result
+    )
+
+    result = cloud_instance.refresh()
+
+    get_state_mock.assert_called_once()
+    assert result == expected_result
+
+
+def test_audit(patch_cloud_init, mocker):
+    """Test execution of Audits for all models in cloud."""
+    cloud_name = "Test Cloud"
+    lint_rules = "some lint rules"
+    override_rules = "some overrides"
+    cloud_type = "openstack"
+    cloud_state = {
+        "controller_foo": {
+            "models": {
+                "model_foo_1": {"name": "foo_1"},
+                "model_foo_2": {"name": "foo_2"},
+            }
+        },
+        "controller_bar": {
+            "models": {
+                "model_bar_1": {"name": "bar_1"},
+                "model_bar_2": {"name": "bar_2"},
+            }
+        },
+    }
+    expected_linter_init_calls = []
+    expected_do_lint_calls = []
+    expected_read_rules_calls = []
+    for controller, controller_data in cloud_state.items():
+        for model, model_data in controller_data["models"].items():
+            expected_linter_init_calls.append(
+                call(
+                    cloud_name,
+                    lint_rules,
+                    overrides=override_rules,
+                    cloud_type=cloud_type,
+                    controller_name=controller,
+                    model_name=model,
+                )
+            )
+            expected_do_lint_calls.append(call(model_data))
+            expected_read_rules_calls.append(call())
+
+    linter_object_mock = MagicMock()
+
+    linter_class_mock = mocker.patch.object(
+        cloud, "Linter", return_value=linter_object_mock
+    )
+
+    cloud_instance = cloud.Cloud(
+        name=cloud_name,
+        lint_rules=lint_rules,
+        lint_overrides=override_rules,
+        cloud_type=cloud_type,
+    )
+    cloud_instance.cloud_state = cloud_state
+
+    cloud_instance.audit()
+
+    linter_class_mock.assert_has_calls(expected_linter_init_calls)
+    linter_object_mock.read_rules.assert_has_calls(expected_read_rules_calls)
+    linter_object_mock.do_lint.assert_has_calls(expected_do_lint_calls)
diff --git a/tests/test_jujulint.py b/tests/test_jujulint.py
index 6e40b74..6c611f6 100644
--- a/tests/test_jujulint.py
+++ b/tests/test_jujulint.py
@@ -6,7 +6,7 @@ from unittest import mock
 
 import pytest
 
-from jujulint import check_spaces
+from jujulint import check_spaces, lint
 
 
 class TestUtils:
@@ -72,6 +72,31 @@ class TestLinter:
         linter.do_lint(juju_status)
         assert len(linter.output_collector["errors"]) == 0
 
+    def test_minimal_rules_without_subordinates(self, linter, juju_status):
+        """Process rules with none of the applications having subordinate charms."""
+        juju_status["applications"]["ubuntu"]["units"]["ubuntu/0"].pop("subordinates")
+        juju_status["applications"].pop("ntp")
+        linter.lint_rules["subordinates"] = {}
+
+        linter.do_lint(juju_status)
+        assert len(linter.output_collector["errors"]) == 0
+
+    def test_minimal_rules_json_output(self, linter, juju_status, mocker):
+        """Process rules and print output in json format."""
+        expected_output = "{result: dict}"
+        json_mock = mocker.patch.object(
+            lint.json, "dumps", return_value=expected_output
+        )
+        print_mock = mocker.patch("builtins.print")
+
+        linter.output_format = "json"
+        linter.do_lint(juju_status)
+
+        json_mock.assert_called_once_with(
+            linter.output_collector, indent=2, sort_keys=True
+        )
+        print_mock.assert_called_once_with(expected_output)
+
     def test_charm_identification(self, linter, juju_status):
         """Test that applications are mapped to charms."""
         juju_status["applications"]["ubuntu2"] = {
@@ -206,6 +231,19 @@ class TestLinter:
         assert errors[0]["id"] == "AZ-invalid-number"
         assert errors[0]["num_azs"] == 2
 
+    def test_az_missing(self, linter, juju_status, mocker):
+        """Test that AZ parsing logs warning if AZ is not found."""
+        # duplicate a AZ name so we have 2 AZs instead of the expected 3
+        juju_status["machines"]["2"]["hardware"] = ""
+        expected_msg = (
+            "Machine 2 has no availability-zone info in hardware field; skipping."
+        )
+        logger_mock = mocker.patch.object(linter, "_log_with_header")
+
+        linter.do_lint(juju_status)
+
+        logger_mock.assert_any_call(expected_msg, level=logging.WARN)
+
     def test_az_balancing(self, linter, juju_status):
         """Test that applications are balanced across AZs."""
         # add an extra machine in an existing AZ
@@ -614,8 +652,8 @@ applications:
         assert errors[0]["expected_value"] == 3
         assert errors[0]["actual_value"] == 0
 
-    def test_config_isset_false(self, linter, juju_status):
-        """Test the config condition 'isset' false."""
+    def test_config_isset_false_fail(self, linter, juju_status):
+        """Test error handling if config condition 'isset'=false is not met."""
         linter.lint_rules["config"] = {"ubuntu": {"fake-opt": {"isset": False}}}
         juju_status["applications"]["ubuntu"]["options"] = {"fake-opt": 0}
         linter.do_lint(juju_status)
@@ -627,8 +665,17 @@ applications:
         assert errors[0]["rule"] == "fake-opt"
         assert errors[0]["actual_value"] == 0
 
-    def test_config_isset_true(self, linter, juju_status):
-        """Test the config condition 'isset' true."""
+    def test_config_isset_false_pass(self, linter, juju_status):
+        """Test handling if config condition 'isset'=false is met."""
+        linter.lint_rules["config"] = {"ubuntu": {"fake-opt": {"isset": False}}}
+        juju_status["applications"]["ubuntu"]["options"] = {}
+        linter.do_lint(juju_status)
+
+        errors = linter.output_collector["errors"]
+        assert len(errors) == 0
+
+    def test_config_isset_true_fail(self, linter, juju_status):
+        """Test error handling if config condition 'isset'=true is not met."""
         linter.lint_rules["config"] = {"ubuntu": {"fake-opt": {"isset": True}}}
         juju_status["applications"]["ubuntu"]["options"] = {}
         linter.do_lint(juju_status)
@@ -639,6 +686,15 @@ applications:
         assert errors[0]["application"] == "ubuntu"
         assert errors[0]["rule"] == "fake-opt"
 
+    def test_config_isset_true_pass(self, linter, juju_status):
+        """Test handling if config condition 'isset'=true is met."""
+        linter.lint_rules["config"] = {"ubuntu": {"fake-opt": {"isset": True}}}
+        juju_status["applications"]["ubuntu"]["options"] = {"fake-opt": 0}
+        linter.do_lint(juju_status)
+
+        errors = linter.output_collector["errors"]
+        assert len(errors) == 0
+
     def test_config_search_valid(self, linter, juju_status):
         """Test the config condition 'search' when valid."""
         linter.lint_rules["config"] = {
@@ -670,6 +726,62 @@ applications:
         assert errors[0]["expected_value"] == "\\W\\*, \\W\\*, 25000, 27500"
         assert errors[0]["actual_value"] == "[[/, queue1, 10, 20], [\\*, \\*, 10, 20]]"
 
+    def test_config_search_missing(self, linter, mocker):
+        """Test the config search method logs warning if the config option is missing."""
+        app_name = "ubuntu"
+        check_value = 0
+        config_key = "missing-opt"
+        app_config = {}
+        expected_log = (
+            "Application {} has no config for '{}', can't search the regex pattern "
+            "{}."
+        ).format(app_name, config_key, repr(check_value))
+
+        logger_mock = mocker.patch.object(linter, "_log_with_header")
+
+        result = linter.search(app_name, check_value, config_key, app_config)
+
+        assert result is False
+        logger_mock.assert_called_once_with(expected_log, level=logging.WARN)
+
+    def test_check_config_generic_missing_option(self, linter, mocker):
+        """Test behavior of check_config_generic() when config option is missing."""
+        operator_ = lint.ConfigOperator(
+            name="eq", repr="==", check=None, error_template=""
+        )
+        app_name = "ubuntu"
+        check_value = 0
+        config_key = "missing-opt"
+        app_config = {}
+        expected_log = (
+            "Application {} has no config for '{}', cannot determine if {} " "{}."
+        ).format(app_name, config_key, operator_.repr, repr(check_value))
+
+        logger_mock = mocker.patch.object(linter, "_log_with_header")
+
+        result = linter.check_config_generic(
+            operator_, app_name, check_value, config_key, app_config
+        )
+
+        logger_mock.assert_called_once_with(expected_log, level=logging.WARN)
+        assert result is False
+
+    def test_check_config_unknown_check_operator(self, linter, mocker):
+        """Test that warning is logged when unknown check operator is encountered."""
+        app_name = "ubuntu"
+        config = {}
+        bad_rule = "bad_rule"
+        bad_check = "bad_check"
+        rules = {bad_rule: {bad_check: 0}}
+        expected_log = (
+            "Application {} has unknown check operation for {}: " "{}."
+        ).format(app_name, bad_rule, bad_check)
+
+        logger_mock = mocker.patch.object(linter, "_log_with_header")
+
+        linter.check_config(app_name, config, rules)
+        logger_mock.assert_any_call(expected_log, level=logging.WARN)
+
     def test_parse_cmr_apps_export_bundle(self, linter):
         """Test the charm CMR parsing for bundles."""
         parsed_yaml = {
@@ -703,6 +815,16 @@ applications:
         linter.parse_cmr_apps(parsed_yaml)
         assert linter.model.cmr_apps == {"grafana", "nagios"}
 
+    def test_parse_cmr_apps_graylog(self, linter):
+        """Test the charm CMR parsing adds elasticsearch dependency if graylog is present."""
+        parsed_yaml = {
+            "saas": {
+                "graylog": {"url": "foundations-maas:admin/lma.graylog"},
+            }
+        }
+        linter.parse_cmr_apps(parsed_yaml)
+        assert linter.model.cmr_apps == {"graylog", "elasticsearch"}
+
     def test_check_charms_ops_mandatory_crm_success(self, linter):
         """
         Test the logic for checking ops mandatory charms provided via CMR.
@@ -748,8 +870,9 @@ applications:
         rules_path.write_text('---\nkey:\n "value"')
 
         linter.filename = str(rules_path)
-        linter.read_rules()
+        result = linter.read_rules()
         assert linter.lint_rules == {"key": "value"}
+        assert result
 
     def test_read_rules_include(self, linter, tmp_path):
         """Test that rules YAML with an include is imported as expected."""
@@ -760,8 +883,41 @@ applications:
         rules_path.write_text('---\n!include include.yaml\nkey:\n "value"')
 
         linter.filename = str(rules_path)
-        linter.read_rules()
+        result = linter.read_rules()
         assert linter.lint_rules == {"key": "value", "key-inc": "value2"}
+        assert result
+
+    def test_read_rules_overrides(self, linter, tmp_path):
+        """Test application of override values to the rules."""
+        rules_path = tmp_path / "rules.yaml"
+        rules_path.write_text('---\nkey:\n "value"\nsubordinates: {}')
+
+        linter.overrides = "override_1:value_1#override_2:value_2"
+
+        linter.filename = str(rules_path)
+        linter.read_rules()
+        assert linter.lint_rules == {
+            "key": "value",
+            "subordinates": {
+                "override_1": {"where": "value_1"},
+                "override_2": {"where": "value_2"},
+            },
+        }
+
+    def test_read_rules_fail(self, linter, mocker):
+        """Test handling of a read_rules() failure."""
+        rule_file = "rules.yaml"
+        mocker.patch.object(lint.os.path, "isfile", return_value=False)
+        logger_mock = mock.MagicMock()
+        linter.logger = logger_mock
+        linter.filename = rule_file
+
+        result = linter.read_rules()
+
+        assert not result
+        logger_mock.error.assert_called_once_with(
+            "Rules file {} does not exist.".format(rule_file)
+        )
 
     check_spaces_example_bundle = {
         "applications": {
@@ -993,3 +1149,65 @@ applications:
 
         linter.check_spaces(bundle)
         assert logger_mock.warning.call_args_list == expected_warning_callings
+
+    def test_check_spaces_exception_handling(self, linter, mocker):
+        """Test exception handling during check_spaces() method."""
+        logger_mock = mock.MagicMock()
+        expected_traceback = "python traceback"
+        expected_msg = (
+            "Exception caught during space check; please check space "
+            "by hand. {}".format(expected_traceback)
+        )
+        mocker.patch.object(linter, "_handle_space_mismatch", side_effect=RuntimeError)
+        mocker.patch.object(
+            lint.traceback, "format_exc", return_value=expected_traceback
+        )
+        linter.logger = logger_mock
+        linter.model.app_to_charm = self.check_spaces_example_app_charm_map
+
+        # Run the space check.
+        # Based on the above bundle, we should have exactly one mismatch.
+        linter.check_spaces(self.check_spaces_example_bundle)
+
+        logger_mock.warn.assert_called_once_with(expected_msg)
+
+    @pytest.mark.parametrize(
+        "regex_error, check_value, actual_value",
+        [
+            (True, "same", "same"),
+            (True, "same", "different"),
+            (False, "same", "same"),
+            (False, "same", "different"),
+        ],
+    )
+    def test_helper_operator_check(
+        self, regex_error, check_value, actual_value, mocker
+    ):
+        """Test comparing values using "helper_operator_check()" function."""
+        if regex_error:
+            mocker.patch.object(lint.re, "match", side_effect=lint.re.error(""))
+
+        expected_result = check_value == actual_value
+
+        result = lint.helper_operator_eq_check(check_value, actual_value)
+
+        assert bool(result) == expected_result
+
+    @pytest.mark.parametrize(
+        "input_str, expected_int",
+        [
+            (1, 1),  # return non-strings unchanged
+            ("not_number_1", "not_number_1"),  # return non-numbers unchanged
+            ("not_number_g", "not_number_g"),  # invalid value with valid suffix
+            ("2f", "2f"),  # unrecognized suffix returns value unchanged
+            ("2k", 2000),  # convert kilo suffix with quotient 1000
+            ("2K", 2048),  # convert Kilo suffix with quotient 1024
+            ("2m", 2000000),  # convert mega suffix with quotient 1000
+            ("2M", 2097152),  # convert Mega suffix with quotient 1024
+            ("2g", 2000000000),  # convert giga suffix with quotient 1000
+            ("2G", 2147483648),  # convert Giga suffix with quotient 1024
+        ],
+    )
+    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
diff --git a/tests/test_k8s.py b/tests/test_k8s.py
new file mode 100644
index 0000000..67835ad
--- /dev/null
+++ b/tests/test_k8s.py
@@ -0,0 +1,29 @@
+"""Tests for Kubernetes cloud module."""
+from unittest.mock import MagicMock
+
+from jujulint.k8s import Cloud, Kubernetes
+
+
+def test_init():
+    """Test Openstack cloud class initiation."""
+    cloud = Kubernetes(name="foo")
+    assert cloud.cloud_type == "kubernetes"
+
+
+def test_audit(mocker):
+    """Test openstack-specific steps of audit method.
+
+    Note: Currently this method does not do anything different than its
+    parent method.
+    """
+    audit_mock = mocker.patch.object(Cloud, "audit")
+    logger_mock = MagicMock()
+
+    name = "foo"
+    cloud = Kubernetes(name=name)
+    cloud.logger = logger_mock
+    expected_msg = "[{}] Running Kubernetes-specific audit steps.".format(name)
+    cloud.audit()
+
+    logger_mock.info.assert_called_once_with(expected_msg)
+    audit_mock.assert_called_once()
diff --git a/tests/test_logging.py b/tests/test_logging.py
new file mode 100644
index 0000000..ad23ac7
--- /dev/null
+++ b/tests/test_logging.py
@@ -0,0 +1,216 @@
+"""Test for jujulint logging module."""
+import sys
+from unittest.mock import MagicMock, call
+
+import pytest
+
+from jujulint import logging
+
+
+def test_logger_init_with_handlers(mocker):
+    """Test initiation of a Logger instance with handlers already present."""
+    color_logger_mock = mocker.patch.object(logging, "colorlog")
+    color_logger_instance_mock = MagicMock()
+    color_logger_instance_mock.handlers = ["handler1", "handler2"]
+    color_logger_mock.getLogger.return_value = color_logger_instance_mock
+    set_level_mock = mocker.patch.object(logging.Logger, "set_level")
+
+    level = "Debug"
+    _ = logging.Logger(level=level)
+
+    color_logger_mock.getLogger.assert_called_once()
+    set_level_mock.assert_called_once_with(level)
+    # No new logger handlers were added since the logger instance already had some.
+    color_logger_instance_mock.addHandler.assert_not_called()
+
+
[e-mail]("setup_file_logger", (False, True))
+def test_logger_init_without_handlers(setup_file_logger, mocker):
+    """Test initiation of a Logger instance that needs to create its own handlers.
+
+    This test has two variants, with and without setting up a file logger as well.
+    """
+    logfile = "/tmp/foo" if setup_file_logger else None
+    # Mock getLogger and resulting object
+    console_logger_mock = MagicMock()
+    file_logger_mock = MagicMock()
+    get_logger_mock = mocker.patch.object(
+        logging.colorlog,
+        "getLogger",
+        side_effect=[
+            console_logger_mock,
+            file_logger_mock,
+        ],
+    )
+    console_logger_mock.handlers = []
+
+    # Mock FileHandler and FileFormatter
+    filehandler_mock = MagicMock()
+    mocker.patch.object(logging.logging, "FileHandler", return_value=filehandler_mock)
+
+    file_formatter_mock = MagicMock()
+    mocker.patch.object(logging.logging, "Formatter", return_value=file_formatter_mock)
+
+    # Mock StreamHandler and resulting object
+    streamhandler_mock = MagicMock()
+    mocker.patch.object(
+        logging.colorlog, "StreamHandler", return_value=streamhandler_mock
+    )
+
+    set_level_mock = mocker.patch.object(logging.Logger, "set_level")
+    # Mock TTYColorFormatter
+    color_formatter_instance = MagicMock()
+    color_formatter_mock = mocker.patch.object(
+        logging.colorlog, "TTYColoredFormatter", return_value=color_formatter_instance
+    )
+    level = "Debug"
+    logformat_string = "%(log_color)s%(asctime)s [%(levelname)s] %(message)s"
+    date_format = "%Y-%m-%d %H:%M:%S"
+
+    _ = logging.Logger(level=level, logfile=logfile)
+
+    # Test creation of new log handler
+    set_level_mock.assert_called_once_with(level)
+    color_formatter_mock.assert_called_once_with(
+        logformat_string,
+        datefmt=date_format,
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red,bg_white",
+        },
+        stream=sys.stdout,
+    )
+    streamhandler_mock.setFormatter.assert_called_once_with(color_formatter_instance)
+
+    if not setup_file_logger:
+        # getLogger and addHandler are called only once if we are not setting up file
+        # logger
+        get_logger_mock.assert_called_once()
+        console_logger_mock.addHandler.assert_called_once_with(streamhandler_mock)
+    else:
+        # These steps need to be verified when __init__ sets up file logger as well
+        get_logger_mock.assert_has_calls([call(), call("file")])
+
+        logging.logging.Formatter.assert_called_once_with(
+            logformat_string, datefmt=date_format
+        )
+        assert not file_logger_mock.propagate
+        logging.logging.FileHandler.assert_called_once_with(logfile)
+        filehandler_mock.setFormatter.assert_called_once_with(file_formatter_mock)
+
+        console_logger_mock.addHandler.assert_has_calls(
+            [
+                call(streamhandler_mock),
+                call(filehandler_mock),
+            ]
+        )
+        file_logger_mock.addHandler.assert_called_once_with(filehandler_mock)
+
+
[e-mail]("exit_code", [None, 0, 1, 2])
+def test_fubar(exit_code, mocker):
+    """Test method that prints to STDERR and ends program execution."""
+    err_msg = "foo bar"
+    expected_error = "E: {}\n".format(err_msg)
+
+    mocker.patch.object(logging.sys.stderr, "write")
+    mocker.patch.object(logging.sys, "exit")
+
+    if exit_code is None:
+        expected_exit_code = 1
+        logging.Logger.fubar(err_msg)
+    else:
+        expected_exit_code = exit_code
+        logging.Logger.fubar(err_msg, exit_code)
+
+    logging.sys.stderr.write.assert_called_once_with(expected_error)
+    logging.sys.exit.assert_called_once_with(expected_exit_code)
+
+
[e-mail](
+    "loglevel, expected_level",
+    [
+        ("DEBUG", logging.logging.DEBUG),
+        ("INFO", logging.logging.INFO),
+        ("WARN", logging.logging.WARN),
+        ("ERROR", logging.logging.ERROR),
+        ("Foo", logging.logging.INFO),
+    ],
+)
+def test_set_level(loglevel, expected_level, mocker):
+    """Test setting various log levels."""
+    bound_logger_mock = MagicMock()
+    mocker.patch.object(logging.colorlog, "getLogger", return_value=bound_logger_mock)
+    basic_config_mock = mocker.patch.object(logging.logging, "basicConfig")
+
+    logger = logging.Logger()
+    logger.set_level(loglevel)
+
+    if loglevel.lower() == "debug":
+        basic_config_mock.assert_called_once_with(level=expected_level)
+    else:
+        bound_logger_mock.setLevel.assert_called_once_with(expected_level)
+
+
+def test_debug_method(mocker):
+    """Test behavior of Logger.debug() method."""
+    message = "Log message"
+    bound_logger_mock = MagicMock()
+    mocker.patch.object(logging.colorlog, "getLogger", return_value=bound_logger_mock)
+
+    logger = logging.Logger()
+    logger.debug(message)
+
+    bound_logger_mock.debug.assert_called_once_with(message)
+
+
+def test_warn_method(mocker):
+    """Test behavior of Logger.warn() method."""
+    message = "Log message"
+    bound_logger_mock = MagicMock()
+    mocker.patch.object(logging.colorlog, "getLogger", return_value=bound_logger_mock)
+
+    logger = logging.Logger()
+    logger.warn(message)
+
+    bound_logger_mock.warn.assert_called_once_with(message)
+
+
+def test_info_method(mocker):
+    """Test behavior of Logger.info() method."""
+    message = "Log message"
+    bound_logger_mock = MagicMock()
+    mocker.patch.object(logging.colorlog, "getLogger", return_value=bound_logger_mock)
+
+    logger = logging.Logger()
+    logger.info(message)
+
+    bound_logger_mock.info.assert_called_once_with(message)
+
+
+def test_error_method(mocker):
+    """Test behavior of Logger.error() method."""
+    message = "Log message"
+    bound_logger_mock = MagicMock()
+    mocker.patch.object(logging.colorlog, "getLogger", return_value=bound_logger_mock)
+
+    logger = logging.Logger()
+    logger.error(message)
+
+    bound_logger_mock.error.assert_called_once_with(message)
+
+
+def test_log_method(mocker):
+    """Test behavior of Logger.log() method."""
+    message = "Log message"
+    level = logging.logging.INFO
+    bound_logger_mock = MagicMock()
+    mocker.patch.object(logging.colorlog, "getLogger", return_value=bound_logger_mock)
+
+    logger = logging.Logger()
+    logger.log(message, level)
+
+    bound_logger_mock.log.assert_called_once_with(level, message)
diff --git a/tests/test_openstack.py b/tests/test_openstack.py
new file mode 100644
index 0000000..cd52b56
--- /dev/null
+++ b/tests/test_openstack.py
@@ -0,0 +1,29 @@
+"""Tests for OpenStack cloud module."""
+from unittest.mock import MagicMock
+
+from jujulint.openstack import Cloud, OpenStack
+
+
+def test_init():
+    """Test Openstack cloud class initiation."""
+    cloud = OpenStack(name="foo")
+    assert cloud.cloud_type == "openstack"
+
+
+def test_audit(mocker):
+    """Test openstack-specific steps of audit method.
+
+    Note: Currently this method does not do anything different than its
+    parent method.
+    """
+    audit_mock = mocker.patch.object(Cloud, "audit")
+    logger_mock = MagicMock()
+
+    name = "foo"
+    cloud = OpenStack(name=name)
+    cloud.logger = logger_mock
+    expected_msg = "[{}] Running OpenStack-specific audit steps.".format(name)
+    cloud.audit()
+
+    logger_mock.info.assert_called_once_with(expected_msg)
+    audit_mock.assert_called_once()
diff --git a/tox.ini b/tox.ini
index 40349c8..e37275c 100644
--- a/tox.ini
+++ b/tox.ini
@@ -28,6 +28,7 @@ commands =
     --new-first \
     --last-failed \
     --last-failed-no-failures all \
+    --cov-fail-under=100 \
     --cov-report=term-missing \
     --cov-report=annotate:tests/report/coverage-annotated \
     --cov-report=html:tests/report/coverage-html \