openshift_checks: refactor to internalize task_vars

Move task_vars into instance variable so we don't have to pass it
around everywhere. Also store tmp. Make sure both are filled in on
execute_module.

In the process, is_active became an instance method, and task_vars is
basically never used directly outside of test code.

19 files changed, 152 insertions, 182 deletions

diff --git a/roles/openshift_health_checker/test/action_plugin_test.py b/roles/openshift_health_checker/test/action_plugin_test.py
index 9383b233c..2d068be3d 100644
--- a/roles/openshift_health_checker/test/action_plugin_test.py
+++ b/roles/openshift_health_checker/test/action_plugin_test.py
@@ -15,14 +15,13 @@ def fake_check(name='fake_check', tags=None, is_active=True, run_return=None, ru
         name = _name
         tags = _tags or []
 
-        def __init__(self, execute_module=None):
+        def __init__(self, execute_module=None, task_vars=None, tmp=None):
             pass
 
-        @classmethod
-        def is_active(cls, task_vars):
+        def is_active(self):
             return is_active
 
-        def run(self, tmp, task_vars):
+        def run(self):
             if run_exception is not None:
                 raise run_exception
             return run_return
@@ -124,7 +123,7 @@ def test_action_plugin_skip_disabled_checks(plugin, task_vars, monkeypatch):
 def test_action_plugin_run_check_ok(plugin, task_vars, monkeypatch):
     check_return_value = {'ok': 'test'}
     check_class = fake_check(run_return=check_return_value)
-    monkeypatch.setattr(plugin, 'load_known_checks', lambda: {'fake_check': check_class()})
+    monkeypatch.setattr(plugin, 'load_known_checks', lambda tmp, task_vars: {'fake_check': check_class()})
     monkeypatch.setattr('openshift_health_check.resolve_checks', lambda *args: ['fake_check'])
 
     result = plugin.run(tmp=None, task_vars=task_vars)
@@ -138,7 +137,7 @@ def test_action_plugin_run_check_ok(plugin, task_vars, monkeypatch):
 def test_action_plugin_run_check_changed(plugin, task_vars, monkeypatch):
     check_return_value = {'ok': 'test', 'changed': True}
     check_class = fake_check(run_return=check_return_value)
-    monkeypatch.setattr(plugin, 'load_known_checks', lambda: {'fake_check': check_class()})
+    monkeypatch.setattr(plugin, 'load_known_checks', lambda tmp, task_vars: {'fake_check': check_class()})
     monkeypatch.setattr('openshift_health_check.resolve_checks', lambda *args: ['fake_check'])
 
     result = plugin.run(tmp=None, task_vars=task_vars)
@@ -152,7 +151,7 @@ def test_action_plugin_run_check_changed(plugin, task_vars, monkeypatch):
 def test_action_plugin_run_check_fail(plugin, task_vars, monkeypatch):
     check_return_value = {'failed': True}
     check_class = fake_check(run_return=check_return_value)
-    monkeypatch.setattr(plugin, 'load_known_checks', lambda: {'fake_check': check_class()})
+    monkeypatch.setattr(plugin, 'load_known_checks', lambda tmp, task_vars: {'fake_check': check_class()})
     monkeypatch.setattr('openshift_health_check.resolve_checks', lambda *args: ['fake_check'])
 
     result = plugin.run(tmp=None, task_vars=task_vars)
@@ -167,7 +166,7 @@ def test_action_plugin_run_check_exception(plugin, task_vars, monkeypatch):
     exception_msg = 'fake check has an exception'
     run_exception = OpenShiftCheckException(exception_msg)
     check_class = fake_check(run_exception=run_exception)
-    monkeypatch.setattr(plugin, 'load_known_checks', lambda: {'fake_check': check_class()})
+    monkeypatch.setattr(plugin, 'load_known_checks', lambda tmp, task_vars: {'fake_check': check_class()})
     monkeypatch.setattr('openshift_health_check.resolve_checks', lambda *args: ['fake_check'])
 
     result = plugin.run(tmp=None, task_vars=task_vars)
@@ -179,7 +178,7 @@ def test_action_plugin_run_check_exception(plugin, task_vars, monkeypatch):
 
 
 def test_action_plugin_resolve_checks_exception(plugin, task_vars, monkeypatch):
-    monkeypatch.setattr(plugin, 'load_known_checks', lambda: {})
+    monkeypatch.setattr(plugin, 'load_known_checks', lambda tmp, task_vars: {})
 
     result = plugin.run(tmp=None, task_vars=task_vars)
 
diff --git a/roles/openshift_health_checker/test/disk_availability_test.py b/roles/openshift_health_checker/test/disk_availability_test.py
index 945b9eafc..e98d02c58 100644
--- a/roles/openshift_health_checker/test/disk_availability_test.py
+++ b/roles/openshift_health_checker/test/disk_availability_test.py
@@ -17,7 +17,7 @@ def test_is_active(group_names, is_active):
     task_vars = dict(
         group_names=group_names,
     )
-    assert DiskAvailability.is_active(task_vars=task_vars) == is_active
+    assert DiskAvailability(None, task_vars).is_active() == is_active
 
 
 @pytest.mark.parametrize('ansible_mounts,extra_words', [
@@ -30,10 +30,9 @@ def test_cannot_determine_available_disk(ansible_mounts, extra_words):
         group_names=['masters'],
         ansible_mounts=ansible_mounts,
     )
-    check = DiskAvailability(execute_module=fake_execute_module)
 
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        DiskAvailability(fake_execute_module, task_vars).run()
 
     for word in 'determine disk availability'.split() + extra_words:
         assert word in str(excinfo.value)
@@ -93,8 +92,7 @@ def test_succeeds_with_recommended_disk_space(group_names, configured_min, ansib
         ansible_mounts=ansible_mounts,
     )
 
-    check = DiskAvailability(execute_module=fake_execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = DiskAvailability(fake_execute_module, task_vars).run()
 
     assert not result.get('failed', False)
 
@@ -168,8 +166,7 @@ def test_fails_with_insufficient_disk_space(group_names, configured_min, ansible
         ansible_mounts=ansible_mounts,
     )
 
-    check = DiskAvailability(execute_module=fake_execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = DiskAvailability(fake_execute_module, task_vars).run()
 
     assert result['failed']
     for word in 'below recommended'.split() + extra_words:
diff --git a/roles/openshift_health_checker/test/docker_image_availability_test.py b/roles/openshift_health_checker/test/docker_image_availability_test.py
index 3b9e097fb..8d0a53df9 100644
--- a/roles/openshift_health_checker/test/docker_image_availability_test.py
+++ b/roles/openshift_health_checker/test/docker_image_availability_test.py
@@ -21,7 +21,7 @@ def test_is_active(deployment_type, is_containerized, group_names, expect_active
         openshift_deployment_type=deployment_type,
         group_names=group_names,
     )
-    assert DockerImageAvailability.is_active(task_vars=task_vars) == expect_active
+    assert DockerImageAvailability(None, task_vars).is_active() == expect_active
 
 
 @pytest.mark.parametrize("is_containerized,is_atomic", [
@@ -31,7 +31,7 @@ def test_is_active(deployment_type, is_containerized, group_names, expect_active
     (False, True),
 ])
 def test_all_images_available_locally(is_containerized, is_atomic):
-    def execute_module(module_name, module_args, task_vars):
+    def execute_module(module_name, module_args, *_):
         if module_name == "yum":
             return {"changed": True}
 
@@ -42,7 +42,7 @@ def test_all_images_available_locally(is_containerized, is_atomic):
             'images': [module_args['name']],
         }
 
-    result = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
+    result = DockerImageAvailability(execute_module, task_vars=dict(
         openshift=dict(
             common=dict(
                 service_type='origin',
@@ -54,7 +54,7 @@ def test_all_images_available_locally(is_containerized, is_atomic):
         openshift_deployment_type='origin',
         openshift_image_tag='3.4',
         group_names=['nodes', 'masters'],
-    ))
+    )).run()
 
     assert not result.get('failed', False)
 
@@ -64,12 +64,12 @@ def test_all_images_available_locally(is_containerized, is_atomic):
     True,
 ])
 def test_all_images_available_remotely(available_locally):
-    def execute_module(module_name, module_args, task_vars):
+    def execute_module(module_name, *_):
         if module_name == 'docker_image_facts':
             return {'images': [], 'failed': available_locally}
         return {'changed': False}
 
-    result = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
+    result = DockerImageAvailability(execute_module, task_vars=dict(
         openshift=dict(
             common=dict(
                 service_type='origin',
@@ -81,13 +81,13 @@ def test_all_images_available_remotely(available_locally):
         openshift_deployment_type='origin',
         openshift_image_tag='v3.4',
         group_names=['nodes', 'masters'],
-    ))
+    )).run()
 
     assert not result.get('failed', False)
 
 
 def test_all_images_unavailable():
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, *_):
         if module_name == "command":
             return {
                 'failed': True,
@@ -97,8 +97,7 @@ def test_all_images_unavailable():
             'changed': False,
         }
 
-    check = DockerImageAvailability(execute_module=execute_module)
-    actual = check.run(tmp=None, task_vars=dict(
+    actual = DockerImageAvailability(execute_module, task_vars=dict(
         openshift=dict(
             common=dict(
                 service_type='origin',
@@ -110,7 +109,7 @@ def test_all_images_unavailable():
         openshift_deployment_type="openshift-enterprise",
         openshift_image_tag='latest',
         group_names=['nodes', 'masters'],
-    ))
+    )).run()
 
     assert actual['failed']
     assert "required Docker images are not available" in actual['msg']
@@ -127,7 +126,7 @@ def test_all_images_unavailable():
     ),
 ])
 def test_skopeo_update_failure(message, extra_words):
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, *_):
         if module_name == "yum":
             return {
                 "failed": True,
@@ -137,7 +136,7 @@ def test_skopeo_update_failure(message, extra_words):
 
         return {'changed': False}
 
-    actual = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
+    actual = DockerImageAvailability(execute_module, task_vars=dict(
         openshift=dict(
             common=dict(
                 service_type='origin',
@@ -149,7 +148,7 @@ def test_skopeo_update_failure(message, extra_words):
         openshift_deployment_type="openshift-enterprise",
         openshift_image_tag='',
         group_names=['nodes', 'masters'],
-    ))
+    )).run()
 
     assert actual["failed"]
     for word in extra_words:
@@ -162,12 +161,12 @@ def test_skopeo_update_failure(message, extra_words):
     ("openshift-enterprise", []),
 ])
 def test_registry_availability(deployment_type, registries):
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, *_):
         return {
             'changed': False,
         }
 
-    actual = DockerImageAvailability(execute_module=execute_module).run(tmp=None, task_vars=dict(
+    actual = DockerImageAvailability(execute_module, task_vars=dict(
         openshift=dict(
             common=dict(
                 service_type='origin',
@@ -179,7 +178,7 @@ def test_registry_availability(deployment_type, registries):
         openshift_deployment_type=deployment_type,
         openshift_image_tag='',
         group_names=['nodes', 'masters'],
-    ))
+    )).run()
 
     assert not actual.get("failed", False)
 
@@ -258,7 +257,7 @@ def test_required_images(deployment_type, is_containerized, groups, oreg_url, ex
         openshift_image_tag='vtest',
     )
 
-    assert expected == DockerImageAvailability("DUMMY").required_images(task_vars)
+    assert expected == DockerImageAvailability("DUMMY", task_vars).required_images()
 
 
 def test_containerized_etcd():
@@ -272,4 +271,4 @@ def test_containerized_etcd():
         group_names=['etcd'],
     )
     expected = set(['registry.access.redhat.com/rhel7/etcd'])
-    assert expected == DockerImageAvailability("DUMMY").required_images(task_vars)
+    assert expected == DockerImageAvailability("DUMMY", task_vars).required_images()
diff --git a/roles/openshift_health_checker/test/docker_storage_test.py b/roles/openshift_health_checker/test/docker_storage_test.py
index 99c529054..e0dccc062 100644
--- a/roles/openshift_health_checker/test/docker_storage_test.py
+++ b/roles/openshift_health_checker/test/docker_storage_test.py
@@ -4,12 +4,6 @@ from openshift_checks import OpenShiftCheckException
 from openshift_checks.docker_storage import DockerStorage
 
 
-def dummy_check(execute_module=None):
-    def dummy_exec(self, status, task_vars):
-        raise Exception("dummy executor called")
-    return DockerStorage(execute_module=execute_module or dummy_exec)
-
-
 @pytest.mark.parametrize('is_containerized, group_names, is_active', [
     (False, ["masters", "etcd"], False),
     (False, ["masters", "nodes"], True),
@@ -20,7 +14,7 @@ def test_is_active(is_containerized, group_names, is_active):
         openshift=dict(common=dict(is_containerized=is_containerized)),
         group_names=group_names,
     )
-    assert DockerStorage.is_active(task_vars=task_vars) == is_active
+    assert DockerStorage(None, task_vars).is_active() == is_active
 
 
 def non_atomic_task_vars():
@@ -99,17 +93,17 @@ def non_atomic_task_vars():
     ),
 ])
 def test_check_storage_driver(docker_info, failed, expect_msg):
-    def execute_module(module_name, module_args, tmp=None, task_vars=None):
+    def execute_module(module_name, *_):
         if module_name == "yum":
             return {}
         if module_name != "docker_info":
             raise ValueError("not expecting module " + module_name)
         return docker_info
 
-    check = dummy_check(execute_module=execute_module)
-    check.check_dm_usage = lambda status, task_vars: dict()  # stub out for this test
-    check.check_overlay_usage = lambda info, task_vars: dict()  # stub out for this test
-    result = check.run(tmp=None, task_vars=non_atomic_task_vars())
+    check = DockerStorage(execute_module, non_atomic_task_vars())
+    check.check_dm_usage = lambda status: dict()  # stub out for this test
+    check.check_overlay_usage = lambda info: dict()  # stub out for this test
+    result = check.run()
 
     if failed:
         assert result["failed"]
@@ -168,9 +162,9 @@ not_enough_space = {
     ),
 ])
 def test_dm_usage(task_vars, driver_status, vg_free, success, expect_msg):
-    check = dummy_check()
-    check.get_vg_free = lambda pool, task_vars: vg_free
-    result = check.check_dm_usage(driver_status, task_vars)
+    check = DockerStorage(None, task_vars)
+    check.get_vg_free = lambda pool: vg_free
+    result = check.check_dm_usage(driver_status)
     result_success = not result.get("failed")
 
     assert result_success is success
@@ -210,18 +204,18 @@ def test_dm_usage(task_vars, driver_status, vg_free, success, expect_msg):
     )
 ])
 def test_vg_free(pool, command_returns, raises, returns):
-    def execute_module(module_name, module_args, tmp=None, task_vars=None):
+    def execute_module(module_name, *_):
         if module_name != "command":
             raise ValueError("not expecting module " + module_name)
         return command_returns
 
-    check = dummy_check(execute_module=execute_module)
+    check = DockerStorage(execute_module)
     if raises:
         with pytest.raises(OpenShiftCheckException) as err:
-            check.get_vg_free(pool, {})
+            check.get_vg_free(pool)
         assert raises in str(err.value)
     else:
-        ret = check.get_vg_free(pool, {})
+        ret = check.get_vg_free(pool)
         assert ret == returns
 
 
@@ -298,13 +292,13 @@ ansible_mounts_zero_size = [{
     ),
 ])
 def test_overlay_usage(ansible_mounts, threshold, expect_fail, expect_msg):
-    check = dummy_check()
     task_vars = non_atomic_task_vars()
     task_vars["ansible_mounts"] = ansible_mounts
     if threshold is not None:
         task_vars["max_overlay_usage_percent"] = threshold
+    check = DockerStorage(None, task_vars)
     docker_info = dict(DockerRootDir="/var/lib/docker", Driver="overlay")
-    result = check.check_overlay_usage(docker_info, task_vars)
+    result = check.check_overlay_usage(docker_info)
 
     assert expect_fail == bool(result.get("failed"))
     for msg in expect_msg:
diff --git a/roles/openshift_health_checker/test/elasticsearch_test.py b/roles/openshift_health_checker/test/elasticsearch_test.py
index b9d375d8c..9edfc17c7 100644
--- a/roles/openshift_health_checker/test/elasticsearch_test.py
+++ b/roles/openshift_health_checker/test/elasticsearch_test.py
@@ -6,9 +6,9 @@ from openshift_checks.logging.elasticsearch import Elasticsearch
 task_vars_config_base = dict(openshift=dict(common=dict(config_base='/etc/origin')))
 
 
-def canned_elasticsearch(exec_oc=None):
+def canned_elasticsearch(task_vars=None, exec_oc=None):
     """Create an Elasticsearch check object with canned exec_oc method"""
-    check = Elasticsearch("dummy")  # fails if a module is actually invoked
+    check = Elasticsearch("dummy", task_vars or {})  # fails if a module is actually invoked
     if exec_oc:
         check._exec_oc = exec_oc
     return check
@@ -50,10 +50,10 @@ split_es_pod = {
 
 
 def test_check_elasticsearch():
-    assert 'No logging Elasticsearch pods' in canned_elasticsearch().check_elasticsearch([], {})
+    assert 'No logging Elasticsearch pods' in canned_elasticsearch().check_elasticsearch([])
 
     # canned oc responses to match so all the checks pass
-    def _exec_oc(cmd, args, task_vars):
+    def _exec_oc(cmd, args):
         if '_cat/master' in cmd:
             return 'name logging-es'
         elif '/_nodes' in cmd:
@@ -65,7 +65,7 @@ def test_check_elasticsearch():
         else:
             raise Exception(cmd)
 
-    assert not canned_elasticsearch(_exec_oc).check_elasticsearch([plain_es_pod], {})
+    assert not canned_elasticsearch({}, _exec_oc).check_elasticsearch([plain_es_pod])
 
 
 def pods_by_name(pods):
@@ -88,9 +88,9 @@ def pods_by_name(pods):
 ])
 def test_check_elasticsearch_masters(pods, expect_error):
     test_pods = list(pods)
-    check = canned_elasticsearch(lambda cmd, args, task_vars: test_pods.pop(0)['_test_master_name_str'])
+    check = canned_elasticsearch(task_vars_config_base, lambda cmd, args: test_pods.pop(0)['_test_master_name_str'])
 
-    errors = check._check_elasticsearch_masters(pods_by_name(pods), task_vars_config_base)
+    errors = check._check_elasticsearch_masters(pods_by_name(pods))
     assert_error(''.join(errors), expect_error)
 
 
@@ -124,9 +124,9 @@ es_node_list = {
     ),
 ])
 def test_check_elasticsearch_node_list(pods, node_list, expect_error):
-    check = canned_elasticsearch(lambda cmd, args, task_vars: json.dumps(node_list))
+    check = canned_elasticsearch(task_vars_config_base, lambda cmd, args: json.dumps(node_list))
 
-    errors = check._check_elasticsearch_node_list(pods_by_name(pods), task_vars_config_base)
+    errors = check._check_elasticsearch_node_list(pods_by_name(pods))
     assert_error(''.join(errors), expect_error)
 
 
@@ -149,9 +149,9 @@ def test_check_elasticsearch_node_list(pods, node_list, expect_error):
 ])
 def test_check_elasticsearch_cluster_health(pods, health_data, expect_error):
     test_health_data = list(health_data)
-    check = canned_elasticsearch(lambda cmd, args, task_vars: json.dumps(test_health_data.pop(0)))
+    check = canned_elasticsearch(task_vars_config_base, lambda cmd, args: json.dumps(test_health_data.pop(0)))
 
-    errors = check._check_es_cluster_health(pods_by_name(pods), task_vars_config_base)
+    errors = check._check_es_cluster_health(pods_by_name(pods))
     assert_error(''.join(errors), expect_error)
 
 
@@ -174,7 +174,7 @@ def test_check_elasticsearch_cluster_health(pods, health_data, expect_error):
     ),
 ])
 def test_check_elasticsearch_diskspace(disk_data, expect_error):
-    check = canned_elasticsearch(lambda cmd, args, task_vars: disk_data)
+    check = canned_elasticsearch(task_vars_config_base, lambda cmd, args: disk_data)
 
-    errors = check._check_elasticsearch_diskspace(pods_by_name([plain_es_pod]), task_vars_config_base)
+    errors = check._check_elasticsearch_diskspace(pods_by_name([plain_es_pod]))
     assert_error(''.join(errors), expect_error)
diff --git a/roles/openshift_health_checker/test/etcd_imagedata_size_test.py b/roles/openshift_health_checker/test/etcd_imagedata_size_test.py
index df9d52d41..e3d6706fa 100644
--- a/roles/openshift_health_checker/test/etcd_imagedata_size_test.py
+++ b/roles/openshift_health_checker/test/etcd_imagedata_size_test.py
@@ -51,10 +51,10 @@ def test_cannot_determine_available_mountpath(ansible_mounts, extra_words):
     task_vars = dict(
         ansible_mounts=ansible_mounts,
     )
-    check = EtcdImageDataSize(execute_module=fake_execute_module)
+    check = EtcdImageDataSize(fake_execute_module, task_vars)
 
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        check.run()
 
     for word in 'determine valid etcd mountpath'.split() + extra_words:
         assert word in str(excinfo.value)
@@ -111,14 +111,14 @@ def test_cannot_determine_available_mountpath(ansible_mounts, extra_words):
     )
 ])
 def test_check_etcd_key_size_calculates_correct_limit(ansible_mounts, tree, size_limit, should_fail, extra_words):
-    def execute_module(module_name, args, tmp=None, task_vars=None):
+    def execute_module(module_name, module_args, *_):
         if module_name != "etcdkeysize":
             return {
                 "changed": False,
             }
 
         client = fake_etcd_client(tree)
-        s, limit_exceeded = check_etcd_key_size(client, tree["key"], args["size_limit_bytes"])
+        s, limit_exceeded = check_etcd_key_size(client, tree["key"], module_args["size_limit_bytes"])
 
         return {"size_limit_exceeded": limit_exceeded}
 
@@ -133,7 +133,7 @@ def test_check_etcd_key_size_calculates_correct_limit(ansible_mounts, tree, size
     if size_limit is None:
         task_vars.pop("etcd_max_image_data_size_bytes")
 
-    check = EtcdImageDataSize(execute_module=execute_module).run(tmp=None, task_vars=task_vars)
+    check = EtcdImageDataSize(execute_module, task_vars).run()
 
     if should_fail:
         assert check["failed"]
@@ -267,14 +267,14 @@ def test_check_etcd_key_size_calculates_correct_limit(ansible_mounts, tree, size
     ),
 ])
 def test_etcd_key_size_check_calculates_correct_size(ansible_mounts, tree, root_path, expected_size, extra_words):
-    def execute_module(module_name, args, tmp=None, task_vars=None):
+    def execute_module(module_name, module_args, *_):
         if module_name != "etcdkeysize":
             return {
                 "changed": False,
             }
 
         client = fake_etcd_client(tree)
-        size, limit_exceeded = check_etcd_key_size(client, root_path, args["size_limit_bytes"])
+        size, limit_exceeded = check_etcd_key_size(client, root_path, module_args["size_limit_bytes"])
 
         assert size == expected_size
         return {
@@ -289,12 +289,12 @@ def test_etcd_key_size_check_calculates_correct_size(ansible_mounts, tree, root_
         )
     )
 
-    check = EtcdImageDataSize(execute_module=execute_module).run(tmp=None, task_vars=task_vars)
+    check = EtcdImageDataSize(execute_module, task_vars).run()
     assert not check.get("failed", False)
 
 
 def test_etcdkeysize_module_failure():
-    def execute_module(module_name, tmp=None, task_vars=None):
+    def execute_module(module_name, *_):
         if module_name != "etcdkeysize":
             return {
                 "changed": False,
@@ -317,7 +317,7 @@ def test_etcdkeysize_module_failure():
         )
     )
 
-    check = EtcdImageDataSize(execute_module=execute_module).run(tmp=None, task_vars=task_vars)
+    check = EtcdImageDataSize(execute_module, task_vars).run()
 
     assert check["failed"]
     for word in "Failed to retrieve stats":
diff --git a/roles/openshift_health_checker/test/etcd_traffic_test.py b/roles/openshift_health_checker/test/etcd_traffic_test.py
index 287175e29..f4316c423 100644
--- a/roles/openshift_health_checker/test/etcd_traffic_test.py
+++ b/roles/openshift_health_checker/test/etcd_traffic_test.py
@@ -21,7 +21,7 @@ def test_is_active(group_names, version, is_active):
             common=dict(short_version=version),
         ),
     )
-    assert EtcdTraffic.is_active(task_vars=task_vars) == is_active
+    assert EtcdTraffic(task_vars=task_vars).is_active() == is_active
 
 
 @pytest.mark.parametrize('group_names,matched,failed,extra_words', [
@@ -30,7 +30,7 @@ def test_is_active(group_names, version, is_active):
     (["etcd"], False, False, []),
 ])
 def test_log_matches_high_traffic_msg(group_names, matched, failed, extra_words):
-    def execute_module(module_name, args, task_vars):
+    def execute_module(module_name, *_):
         return {
             "matched": matched,
             "failed": failed,
@@ -43,8 +43,7 @@ def test_log_matches_high_traffic_msg(group_names, matched, failed, extra_words)
         )
     )
 
-    check = EtcdTraffic(execute_module=execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = EtcdTraffic(execute_module, task_vars).run()
 
     for word in extra_words:
         assert word in result.get("msg", "")
@@ -63,7 +62,7 @@ def test_systemd_unit_matches_deployment_type(is_containerized, expected_unit_va
         )
     )
 
-    def execute_module(module_name, args, task_vars):
+    def execute_module(module_name, args, *_):
         assert module_name == "search_journalctl"
         matchers = args["log_matchers"]
 
@@ -72,9 +71,4 @@ def test_systemd_unit_matches_deployment_type(is_containerized, expected_unit_va
 
         return {"failed": False}
 
-    check = EtcdTraffic(execute_module=execute_module)
-    check.run(tmp=None, task_vars=task_vars)
-
-
-def fake_execute_module(*args):
-    raise AssertionError('this function should not be called')
+    EtcdTraffic(execute_module, task_vars).run()
diff --git a/roles/openshift_health_checker/test/etcd_volume_test.py b/roles/openshift_health_checker/test/etcd_volume_test.py
index 917045526..0b255136e 100644
--- a/roles/openshift_health_checker/test/etcd_volume_test.py
+++ b/roles/openshift_health_checker/test/etcd_volume_test.py
@@ -11,10 +11,9 @@ def test_cannot_determine_available_disk(ansible_mounts, extra_words):
     task_vars = dict(
         ansible_mounts=ansible_mounts,
     )
-    check = EtcdVolume(execute_module=fake_execute_module)
 
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        EtcdVolume(fake_execute_module, task_vars).run()
 
     for word in 'Unable to find etcd storage mount point'.split() + extra_words:
         assert word in str(excinfo.value)
@@ -76,8 +75,7 @@ def test_succeeds_with_recommended_disk_space(size_limit, ansible_mounts):
     if task_vars["etcd_device_usage_threshold_percent"] is None:
         task_vars.pop("etcd_device_usage_threshold_percent")
 
-    check = EtcdVolume(execute_module=fake_execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = EtcdVolume(fake_execute_module, task_vars).run()
 
     assert not result.get('failed', False)
 
@@ -137,8 +135,7 @@ def test_fails_with_insufficient_disk_space(size_limit_percent, ansible_mounts,
     if task_vars["etcd_device_usage_threshold_percent"] is None:
         task_vars.pop("etcd_device_usage_threshold_percent")
 
-    check = EtcdVolume(execute_module=fake_execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = EtcdVolume(fake_execute_module, task_vars).run()
 
     assert result['failed']
     for word in extra_words:
diff --git a/roles/openshift_health_checker/test/fluentd_test.py b/roles/openshift_health_checker/test/fluentd_test.py
index d151c0b19..9cee57868 100644
--- a/roles/openshift_health_checker/test/fluentd_test.py
+++ b/roles/openshift_health_checker/test/fluentd_test.py
@@ -103,7 +103,7 @@ fluentd_node3_unlabeled = {
     ),
 ])
 def test_get_fluentd_pods(pods, nodes, expect_error):
-    check = canned_fluentd(lambda cmd, args, task_vars: json.dumps(dict(items=nodes)))
+    check = canned_fluentd(exec_oc=lambda cmd, args: json.dumps(dict(items=nodes)))
 
-    error = check.check_fluentd(pods, {})
+    error = check.check_fluentd(pods)
     assert_error(error, expect_error)
diff --git a/roles/openshift_health_checker/test/kibana_test.py b/roles/openshift_health_checker/test/kibana_test.py
index 40a5d19d8..3a880d300 100644
--- a/roles/openshift_health_checker/test/kibana_test.py
+++ b/roles/openshift_health_checker/test/kibana_test.py
@@ -13,7 +13,7 @@ from openshift_checks.logging.kibana import Kibana
 
 def canned_kibana(exec_oc=None):
     """Create a Kibana check object with canned exec_oc method"""
-    check = Kibana("dummy")  # fails if a module is actually invoked
+    check = Kibana()  # fails if a module is actually invoked
     if exec_oc:
         check._exec_oc = exec_oc
     return check
@@ -137,9 +137,9 @@ def test_check_kibana(pods, expect_error):
     ),
 ])
 def test_get_kibana_url(route, expect_url, expect_error):
-    check = canned_kibana(lambda cmd, args, task_vars: json.dumps(route) if route else "")
+    check = canned_kibana(exec_oc=lambda cmd, args: json.dumps(route) if route else "")
 
-    url, error = check._get_kibana_url({})
+    url, error = check._get_kibana_url()
     if expect_url:
         assert url == expect_url
     else:
@@ -169,10 +169,10 @@ def test_get_kibana_url(route, expect_url, expect_error):
     ),
 ])
 def test_verify_url_internal_failure(exec_result, expect):
-    check = Kibana(execute_module=lambda module_name, args, tmp, task_vars: dict(failed=True, msg=exec_result))
-    check._get_kibana_url = lambda task_vars: ('url', None)
+    check = Kibana(execute_module=lambda *_: dict(failed=True, msg=exec_result))
+    check._get_kibana_url = lambda: ('url', None)
 
-    error = check._check_kibana_route({})
+    error = check._check_kibana_route()
     assert_error(error, expect)
 
 
@@ -211,8 +211,8 @@ def test_verify_url_external_failure(lib_result, expect, monkeypatch):
     monkeypatch.setattr(urllib2, 'urlopen', urlopen)
 
     check = canned_kibana()
-    check._get_kibana_url = lambda task_vars: ('url', None)
-    check._verify_url_internal = lambda url, task_vars: None
+    check._get_kibana_url = lambda: ('url', None)
+    check._verify_url_internal = lambda url: None
 
-    error = check._check_kibana_route({})
+    error = check._check_kibana_route()
     assert_error(error, expect)
diff --git a/roles/openshift_health_checker/test/logging_check_test.py b/roles/openshift_health_checker/test/logging_check_test.py
index 4f71fbf52..6f1697ee6 100644
--- a/roles/openshift_health_checker/test/logging_check_test.py
+++ b/roles/openshift_health_checker/test/logging_check_test.py
@@ -11,7 +11,7 @@ logging_namespace = "logging"
 
 def canned_loggingcheck(exec_oc=None):
     """Create a LoggingCheck object with canned exec_oc method"""
-    check = LoggingCheck("dummy")  # fails if a module is actually invoked
+    check = LoggingCheck()  # fails if a module is actually invoked
     check.logging_namespace = 'logging'
     if exec_oc:
         check.exec_oc = exec_oc
@@ -90,15 +90,15 @@ plain_curator_pod = {
     ("Permission denied", "Unexpected error using `oc`"),
 ])
 def test_oc_failure(problem, expect):
-    def execute_module(module_name, args, tmp, task_vars):
+    def execute_module(module_name, *_):
         if module_name == "ocutil":
             return dict(failed=True, result=problem)
         return dict(changed=False)
 
-    check = LoggingCheck({})
+    check = LoggingCheck(execute_module, task_vars_config_base)
 
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.exec_oc(execute_module, logging_namespace, 'get foo', [], task_vars=task_vars_config_base)
+        check.exec_oc(logging_namespace, 'get foo', [])
     assert expect in str(excinfo)
 
 
@@ -121,7 +121,7 @@ def test_is_active(groups, logging_deployed, is_active):
         openshift_hosted_logging_deploy=logging_deployed,
     )
 
-    assert LoggingCheck.is_active(task_vars=task_vars) == is_active
+    assert LoggingCheck(None, task_vars).is_active() == is_active
 
 
 @pytest.mark.parametrize('pod_output, expect_pods, expect_error', [
@@ -137,12 +137,10 @@ def test_is_active(groups, logging_deployed, is_active):
     ),
 ])
 def test_get_pods_for_component(pod_output, expect_pods, expect_error):
-    check = canned_loggingcheck(lambda exec_module, namespace, cmd, args, task_vars: pod_output)
+    check = canned_loggingcheck(lambda namespace, cmd, args: pod_output)
     pods, error = check.get_pods_for_component(
-        lambda name, args, task_vars: {},
         logging_namespace,
         "es",
-        {}
     )
     assert_error(error, expect_error)
 
diff --git a/roles/openshift_health_checker/test/logging_index_time_test.py b/roles/openshift_health_checker/test/logging_index_time_test.py
index 79e7c7d4c..178d7cd84 100644
--- a/roles/openshift_health_checker/test/logging_index_time_test.py
+++ b/roles/openshift_health_checker/test/logging_index_time_test.py
@@ -10,7 +10,7 @@ SAMPLE_UUID = "unique-test-uuid"
 
 def canned_loggingindextime(exec_oc=None):
     """Create a check object with a canned exec_oc method"""
-    check = LoggingIndexTime("dummy")  # fails if a module is actually invoked
+    check = LoggingIndexTime()  # fails if a module is actually invoked
     if exec_oc:
         check.exec_oc = exec_oc
     return check
@@ -64,7 +64,7 @@ not_running_kibana_pod = {
     )
 ])
 def test_check_running_pods(pods, expect_pods):
-    check = canned_loggingindextime(None)
+    check = canned_loggingindextime()
     pods = check.running_pods(pods)
     assert pods == expect_pods
 
@@ -81,11 +81,8 @@ def test_check_running_pods(pods, expect_pods):
     ),
 ], ids=lambda argval: argval[0])
 def test_wait_until_cmd_or_err_succeeds(name, json_response, uuid, timeout, extra_words):
-    def exec_oc(execute_module, ns, exec_cmd, args, task_vars):
-        return json.dumps(json_response)
-
-    check = canned_loggingindextime(exec_oc)
-    check.wait_until_cmd_or_err(plain_running_elasticsearch_pod, uuid, timeout, None)
+    check = canned_loggingindextime(lambda *_: json.dumps(json_response))
+    check.wait_until_cmd_or_err(plain_running_elasticsearch_pod, uuid, timeout)
 
 
 @pytest.mark.parametrize('name, json_response, uuid, timeout, extra_words', [
@@ -116,12 +113,9 @@ def test_wait_until_cmd_or_err_succeeds(name, json_response, uuid, timeout, extr
     )
 ], ids=lambda argval: argval[0])
 def test_wait_until_cmd_or_err(name, json_response, uuid, timeout, extra_words):
-    def exec_oc(execute_module, ns, exec_cmd, args, task_vars):
-        return json.dumps(json_response)
-
-    check = canned_loggingindextime(exec_oc)
+    check = canned_loggingindextime(lambda *_: json.dumps(json_response))
     with pytest.raises(OpenShiftCheckException) as error:
-        check.wait_until_cmd_or_err(plain_running_elasticsearch_pod, uuid, timeout, None)
+        check.wait_until_cmd_or_err(plain_running_elasticsearch_pod, uuid, timeout)
 
     for word in extra_words:
         assert word in str(error)
@@ -138,13 +132,10 @@ def test_wait_until_cmd_or_err(name, json_response, uuid, timeout, extra_words):
     ),
 ], ids=lambda argval: argval[0])
 def test_curl_kibana_with_uuid(name, json_response, uuid, extra_words):
-    def exec_oc(execute_module, ns, exec_cmd, args, task_vars):
-        return json.dumps(json_response)
-
-    check = canned_loggingindextime(exec_oc)
+    check = canned_loggingindextime(lambda *_: json.dumps(json_response))
     check.generate_uuid = lambda: uuid
 
-    result = check.curl_kibana_with_uuid(plain_running_kibana_pod, None)
+    result = check.curl_kibana_with_uuid(plain_running_kibana_pod)
 
     for word in extra_words:
         assert word in result
@@ -169,14 +160,11 @@ def test_curl_kibana_with_uuid(name, json_response, uuid, extra_words):
     ),
 ], ids=lambda argval: argval[0])
 def test_failed_curl_kibana_with_uuid(name, json_response, uuid, extra_words):
-    def exec_oc(execute_module, ns, exec_cmd, args, task_vars):
-        return json.dumps(json_response)
-
-    check = canned_loggingindextime(exec_oc)
+    check = canned_loggingindextime(lambda *_: json.dumps(json_response))
     check.generate_uuid = lambda: uuid
 
     with pytest.raises(OpenShiftCheckException) as error:
-        check.curl_kibana_with_uuid(plain_running_kibana_pod, None)
+        check.curl_kibana_with_uuid(plain_running_kibana_pod)
 
     for word in extra_words:
         assert word in str(error)
diff --git a/roles/openshift_health_checker/test/memory_availability_test.py b/roles/openshift_health_checker/test/memory_availability_test.py
index 4fbaea0a9..aee2f0416 100644
--- a/roles/openshift_health_checker/test/memory_availability_test.py
+++ b/roles/openshift_health_checker/test/memory_availability_test.py
@@ -17,7 +17,7 @@ def test_is_active(group_names, is_active):
     task_vars = dict(
         group_names=group_names,
     )
-    assert MemoryAvailability.is_active(task_vars=task_vars) == is_active
+    assert MemoryAvailability(None, task_vars).is_active() == is_active
 
 
 @pytest.mark.parametrize('group_names,configured_min,ansible_memtotal_mb', [
@@ -59,8 +59,7 @@ def test_succeeds_with_recommended_memory(group_names, configured_min, ansible_m
         ansible_memtotal_mb=ansible_memtotal_mb,
     )
 
-    check = MemoryAvailability(execute_module=fake_execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = MemoryAvailability(fake_execute_module, task_vars).run()
 
     assert not result.get('failed', False)
 
@@ -117,8 +116,7 @@ def test_fails_with_insufficient_memory(group_names, configured_min, ansible_mem
         ansible_memtotal_mb=ansible_memtotal_mb,
     )
 
-    check = MemoryAvailability(execute_module=fake_execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = MemoryAvailability(fake_execute_module, task_vars).run()
 
     assert result.get('failed', False)
     for word in 'below recommended'.split() + extra_words:
diff --git a/roles/openshift_health_checker/test/mixins_test.py b/roles/openshift_health_checker/test/mixins_test.py
index 2d83e207d..b1a41ca3c 100644
--- a/roles/openshift_health_checker/test/mixins_test.py
+++ b/roles/openshift_health_checker/test/mixins_test.py
@@ -14,10 +14,10 @@ class NotContainerizedCheck(NotContainerizedMixin, OpenShiftCheck):
     (dict(openshift=dict(common=dict(is_containerized=True))), False),
 ])
 def test_is_active(task_vars, expected):
-    assert NotContainerizedCheck.is_active(task_vars) == expected
+    assert NotContainerizedCheck(None, task_vars).is_active() == expected
 
 
 def test_is_active_missing_task_vars():
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        NotContainerizedCheck.is_active(task_vars={})
+        NotContainerizedCheck().is_active()
     assert 'is_containerized' in str(excinfo.value)
diff --git a/roles/openshift_health_checker/test/openshift_check_test.py b/roles/openshift_health_checker/test/openshift_check_test.py
index c6169ca22..43aa875f4 100644
--- a/roles/openshift_health_checker/test/openshift_check_test.py
+++ b/roles/openshift_health_checker/test/openshift_check_test.py
@@ -1,7 +1,7 @@
 import pytest
 
 from openshift_checks import OpenShiftCheck, OpenShiftCheckException
-from openshift_checks import load_checks, get_var
+from openshift_checks import load_checks
 
 
 # Fixtures
@@ -28,8 +28,8 @@ def test_OpenShiftCheck_init():
         name = "test_check"
         run = NotImplemented
 
-    # initialization requires at least one argument (apart from self)
-    with pytest.raises(TypeError) as excinfo:
+    # execute_module required at init if it will be used
+    with pytest.raises(RuntimeError) as excinfo:
         TestCheck().execute_module("foo")
     assert 'execute_module' in str(excinfo.value)
 
@@ -37,11 +37,14 @@ def test_OpenShiftCheck_init():
 
     # initialize with positional argument
     check = TestCheck(execute_module)
-    assert check.execute_module == execute_module
+    assert check._execute_module == execute_module
 
     # initialize with keyword argument
     check = TestCheck(execute_module=execute_module)
-    assert check.execute_module == execute_module
+    assert check._execute_module == execute_module
+
+    assert check.task_vars == {}
+    assert check.tmp is None
 
 
 def test_subclasses():
@@ -67,19 +70,27 @@ def test_load_checks():
     assert modules
 
 
+def dummy_check(task_vars):
+    class TestCheck(OpenShiftCheck):
+        name = "dummy"
+        run = NotImplemented
+
+    return TestCheck(task_vars=task_vars)
+
+
 @pytest.mark.parametrize("keys,expected", [
     (("foo",), 42),
     (("bar", "baz"), "openshift"),
 ])
 def test_get_var_ok(task_vars, keys, expected):
-    assert get_var(task_vars, *keys) == expected
+    assert dummy_check(task_vars).get_var(*keys) == expected
 
 
 def test_get_var_error(task_vars, missing_keys):
     with pytest.raises(OpenShiftCheckException):
-        get_var(task_vars, *missing_keys)
+        dummy_check(task_vars).get_var(*missing_keys)
 
 
 def test_get_var_default(task_vars, missing_keys):
     default = object()
-    assert get_var(task_vars, *missing_keys, default=default) == default
+    assert dummy_check(task_vars).get_var(*missing_keys, default=default) == default
diff --git a/roles/openshift_health_checker/test/ovs_version_test.py b/roles/openshift_health_checker/test/ovs_version_test.py
index 6494e1c06..b6acef5a6 100644
--- a/roles/openshift_health_checker/test/ovs_version_test.py
+++ b/roles/openshift_health_checker/test/ovs_version_test.py
@@ -4,7 +4,7 @@ from openshift_checks.ovs_version import OvsVersion, OpenShiftCheckException
 
 
 def test_openshift_version_not_supported():
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(*_):
         return {}
 
     openshift_release = '111.7.0'
@@ -16,15 +16,14 @@ def test_openshift_version_not_supported():
         openshift_deployment_type='origin',
     )
 
-    check = OvsVersion(execute_module=execute_module)
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        OvsVersion(execute_module, task_vars).run()
 
     assert "no recommended version of Open vSwitch" in str(excinfo.value)
 
 
 def test_invalid_openshift_release_format():
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(*_):
         return {}
 
     task_vars = dict(
@@ -33,9 +32,8 @@ def test_invalid_openshift_release_format():
         openshift_deployment_type='origin',
     )
 
-    check = OvsVersion(execute_module=execute_module)
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        OvsVersion(execute_module, task_vars).run()
     assert "invalid version" in str(excinfo.value)
 
 
@@ -54,7 +52,7 @@ def test_ovs_package_version(openshift_release, expected_ovs_version):
     )
     return_value = object()
 
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, module_args=None, *_):
         assert module_name == 'rpm_version'
         assert "package_list" in module_args
 
@@ -64,8 +62,7 @@ def test_ovs_package_version(openshift_release, expected_ovs_version):
 
         return return_value
 
-    check = OvsVersion(execute_module=execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = OvsVersion(execute_module, task_vars).run()
     assert result is return_value
 
 
@@ -86,4 +83,4 @@ def test_ovs_version_skip_when_not_master_nor_node(group_names, is_containerized
         group_names=group_names,
         openshift=dict(common=dict(is_containerized=is_containerized)),
     )
-    assert OvsVersion.is_active(task_vars=task_vars) == is_active
+    assert OvsVersion(None, task_vars).is_active() == is_active
diff --git a/roles/openshift_health_checker/test/package_availability_test.py b/roles/openshift_health_checker/test/package_availability_test.py
index f7e916a46..1fe648b75 100644
--- a/roles/openshift_health_checker/test/package_availability_test.py
+++ b/roles/openshift_health_checker/test/package_availability_test.py
@@ -14,7 +14,7 @@ def test_is_active(pkg_mgr, is_containerized, is_active):
         ansible_pkg_mgr=pkg_mgr,
         openshift=dict(common=dict(is_containerized=is_containerized)),
     )
-    assert PackageAvailability.is_active(task_vars=task_vars) == is_active
+    assert PackageAvailability(None, task_vars).is_active() == is_active
 
 
 @pytest.mark.parametrize('task_vars,must_have_packages,must_not_have_packages', [
@@ -51,13 +51,12 @@ def test_is_active(pkg_mgr, is_containerized, is_active):
 def test_package_availability(task_vars, must_have_packages, must_not_have_packages):
     return_value = object()
 
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, module_args=None, *_):
         assert module_name == 'check_yum_update'
         assert 'packages' in module_args
         assert set(module_args['packages']).issuperset(must_have_packages)
         assert not set(module_args['packages']).intersection(must_not_have_packages)
         return return_value
 
-    check = PackageAvailability(execute_module=execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    result = PackageAvailability(execute_module, task_vars).run()
     assert result is return_value
diff --git a/roles/openshift_health_checker/test/package_update_test.py b/roles/openshift_health_checker/test/package_update_test.py
index 5e000cff5..06489b0d7 100644
--- a/roles/openshift_health_checker/test/package_update_test.py
+++ b/roles/openshift_health_checker/test/package_update_test.py
@@ -4,13 +4,12 @@ from openshift_checks.package_update import PackageUpdate
 def test_package_update():
     return_value = object()
 
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, module_args=None, *_):
         assert module_name == 'check_yum_update'
         assert 'packages' in module_args
         # empty list of packages means "generic check if 'yum update' will work"
         assert module_args['packages'] == []
         return return_value
 
-    check = PackageUpdate(execute_module=execute_module)
-    result = check.run(tmp=None, task_vars=None)
+    result = PackageUpdate(execute_module).run()
     assert result is return_value
diff --git a/roles/openshift_health_checker/test/package_version_test.py b/roles/openshift_health_checker/test/package_version_test.py
index 1bb6371ae..1ddb9cecb 100644
--- a/roles/openshift_health_checker/test/package_version_test.py
+++ b/roles/openshift_health_checker/test/package_version_test.py
@@ -8,7 +8,7 @@ from openshift_checks.package_version import PackageVersion, OpenShiftCheckExcep
     ('0.0.0', ["no recommended version of Docker"]),
 ])
 def test_openshift_version_not_supported(openshift_release, extra_words):
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(*_):
         return {}
 
     task_vars = dict(
@@ -18,16 +18,16 @@ def test_openshift_version_not_supported(openshift_release, extra_words):
         openshift_deployment_type='origin',
     )
 
-    check = PackageVersion(execute_module=execute_module)
+    check = PackageVersion(execute_module, task_vars)
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        check.run()
 
     for word in extra_words:
         assert word in str(excinfo.value)
 
 
 def test_invalid_openshift_release_format():
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(*_):
         return {}
 
     task_vars = dict(
@@ -36,9 +36,9 @@ def test_invalid_openshift_release_format():
         openshift_deployment_type='origin',
     )
 
-    check = PackageVersion(execute_module=execute_module)
+    check = PackageVersion(execute_module, task_vars)
     with pytest.raises(OpenShiftCheckException) as excinfo:
-        check.run(tmp=None, task_vars=task_vars)
+        check.run()
     assert "invalid version" in str(excinfo.value)
 
 
@@ -57,7 +57,7 @@ def test_package_version(openshift_release):
     )
     return_value = object()
 
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None, *_):
         assert module_name == 'aos_version'
         assert "package_list" in module_args
 
@@ -67,8 +67,8 @@ def test_package_version(openshift_release):
 
         return return_value
 
-    check = PackageVersion(execute_module=execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    check = PackageVersion(execute_module, task_vars)
+    result = check.run()
     assert result is return_value
 
 
@@ -89,7 +89,7 @@ def test_docker_package_version(deployment_type, openshift_release, expected_doc
     )
     return_value = object()
 
-    def execute_module(module_name=None, module_args=None, tmp=None, task_vars=None):
+    def execute_module(module_name=None, module_args=None, *_):
         assert module_name == 'aos_version'
         assert "package_list" in module_args
 
@@ -99,8 +99,8 @@ def test_docker_package_version(deployment_type, openshift_release, expected_doc
 
         return return_value
 
-    check = PackageVersion(execute_module=execute_module)
-    result = check.run(tmp=None, task_vars=task_vars)
+    check = PackageVersion(execute_module, task_vars)
+    result = check.run()
     assert result is return_value
 
 
@@ -121,4 +121,4 @@ def test_package_version_skip_when_not_master_nor_node(group_names, is_container
         group_names=group_names,
         openshift=dict(common=dict(is_containerized=is_containerized)),
     )
-    assert PackageVersion.is_active(task_vars=task_vars) == is_active
+    assert PackageVersion(None, task_vars).is_active() == is_active