diff --git a/libtaskotron/check.py b/libtaskotron/check.py
--- a/libtaskotron/check.py
+++ b/libtaskotron/check.py
@@ -32,9 +32,9 @@
     builds, updates, etc). That's when this class comes very handy (it can be
     used even for the simple use cases, of course).
 
-    :cvar outcome_priority: a tuple of :attr:`outcome` keywords sorted by
-                            priority from the least important to the most
-                            important
+    :cvar tuple outcome_priority: a tuple of :attr:`outcome` keywords sorted by
+                                  priority from the least important to the most
+                                  important
     :ivar str item: a description the item being tested; for example a build NVR
                     (``vpnc-0.5-1.fc20``), update ID (``FEDORA-2014-3309``) or a
                     repository name (``f20-updates``)
@@ -71,10 +71,10 @@
                        the check run (e.g. ``5 WARNINGS, 1 ERROR`` for an
                        rpmlint result). Should not unnecessarily duplicate
                        :attr:`item` or :attr:`outcome`, if possible.
-    :ivar output: output from the check run (a list of strings). You can easily
-                  populate this by using @method store(), or you can modify it
-                  directly (for example filter out some messages you don't want
-                  to see in the check output).
+    :ivar list output: output from the check run (a list of strings). You can easily
+                       populate this by using :meth:`store`, or you can modify it
+                       directly (for example filter out some messages you don't want
+                       to see in the check output).
     :ivar dict keyvals: all key-value pairs in this dictionary are stored in
                         ResultsDB as 'extra data'. This can be used to store
                         e.g. a compose id or a kernel version, if that
diff --git a/libtaskotron/directives/__init__.py b/libtaskotron/directives/__init__.py
--- a/libtaskotron/directives/__init__.py
+++ b/libtaskotron/directives/__init__.py
@@ -83,11 +83,24 @@
 
 directive_class = 'BaseDirective'
 
+
 class BaseDirective(object):
+    '''The interface definition for all directive classes. They should inherit this and implement
+    required methods.'''
 
     def __init__(self):
         pass
 
-    def process(self, input_data, env_data):
+    def process(self, params, arg_data):
+        '''Main entry point for the directive. Executes the directive.
+
+        :param dict params: all parameters received as an input for this directive. They should
+            reflect what you have documented in ``parameters`` key in ``DOCUMENTATION`` global
+            variable. You have to validate them manually and you should raise
+            ``.TaskotronDirectiveError`` for any missing or invalid input parameter (and also
+            document this behavior in ``raises`` key in ``DOCUMENTATION``).
+        :param dict arg_data: processed runner cli arguments (see :func:`main.process_args`)
+            enriched with additional runtime variables like ``workdir`` or ``checkname`` (see
+            :class:`.Executor`)
+        '''
         raise NotImplementedError
-
diff --git a/libtaskotron/directives/bodhi_directive.py b/libtaskotron/directives/bodhi_directive.py
--- a/libtaskotron/directives/bodhi_directive.py
+++ b/libtaskotron/directives/bodhi_directive.py
@@ -110,34 +110,34 @@
 
         return downloaded_rpms
 
-    def process(self, input_data, env_data):
+    def process(self, params, arg_data):
         output_data = {}
 
         valid_actions = ['download']
 
-        action = input_data['action']
+        action = params['action']
 
         if action not in valid_actions:
             raise TaskotronDirectiveError('%s is not a valid command for bodhi directive'
                                  % action)
 
         if action == 'download':
-            if 'update_id' not in input_data or 'arch' not in input_data:
-                detected_args = ', '.join(input_data.keys())
+            if 'update_id' not in params or 'arch' not in params:
+                detected_args = ', '.join(params.keys())
                 raise TaskotronDirectiveError(
                     "The bodhi directive 'download' requires both 'update_id' and "
                     "'arch' arguments. Detected arguments: %s" % detected_args)
 
-            workdir = env_data['workdir']
-            updateid = input_data['update_id']
-            if 'all' in input_data['arch']:
+            workdir = arg_data['workdir']
+            updateid = params['update_id']
+            if 'all' in params['arch']:
                 arches = Arches.base + ['noarch']
             else:
-                arches = input_data['arch']
+                arches = params['arch']
             if arches and ('noarch' not in arches):
                 arches.append('noarch')
 
-            src = input_data.get('src', False)
+            src = params.get('src', False)
 
             log.info("getting rpms for update %s (%s) and downloading to %s",
                      updateid, arches, workdir)
diff --git a/libtaskotron/directives/create_report_directive.py b/libtaskotron/directives/create_report_directive.py
--- a/libtaskotron/directives/create_report_directive.py
+++ b/libtaskotron/directives/create_report_directive.py
@@ -74,9 +74,9 @@
 
 class CreateReportDirective(BaseDirective):
 
-    def process(self, input_data, env_data):
+    def process(self, params, arg_data):
         try:
-            check_details = check.import_YAML(input_data['results'])
+            check_details = check.import_YAML(params['results'])
             log.debug("YAML output parsed OK.")
         except TaskotronValueError as e:
             raise TaskotronDirectiveError("Failed to load 'results': %s" % e.message)
@@ -86,22 +86,22 @@
         results = []
         for detail in check_details:
             results.append({
-                'checkname': detail.checkname or env_data['checkname'],
+                'checkname': detail.checkname or arg_data['checkname'],
                 'outcome': detail.outcome,
                 'note': detail.note or '---',
                 'item': detail.item,
                 'type': detail.report_type,
                 'artifact': os.path.basename(detail.artifact),
             })
 
-        if 'path' in input_data:
-            report_fname = os.path.join(env_data['artifactsdir'], input_data['path'])
+        if 'path' in params:
+            report_fname = os.path.join(arg_data['artifactsdir'], params['path'])
         else:
-            report_fname = os.path.join(env_data['artifactsdir'], 'report.html')
+            report_fname = os.path.join(arg_data['artifactsdir'], 'report.html')
 
-        if 'template' in input_data:
-            template_fname = os.path.join(os.path.dirname(env_data['task']),
-                                          input_data['template'])
+        if 'template' in params:
+            template_fname = os.path.join(os.path.dirname(arg_data['task']),
+                                          params['template'])
         else:
             template_fname = os.path.join(TEMPL_DIR, 'html.j2')
 
@@ -113,7 +113,8 @@
         with open(template_fname) as f_template:
             with open(report_fname, 'w') as f_report:
                 template = jinja2.Template(f_template.read())
-                report = template.render(results=results, artifactsdir=env_data['artifactsdir'])
+                report = template.render(results=results,
+                                         artifactsdir=arg_data['artifactsdir'])
                 f_report.write(report)
 
         log.info('Report generated in: %s', os.path.abspath(report_fname))
diff --git a/libtaskotron/directives/createrepo_directive.py b/libtaskotron/directives/createrepo_directive.py
--- a/libtaskotron/directives/createrepo_directive.py
+++ b/libtaskotron/directives/createrepo_directive.py
@@ -49,8 +49,8 @@
 
 class CreaterepoDirective(BaseDirective):
 
-    def process(self, input_data, env_data):
-        repodir = input_data['repodir']
+    def process(self, params, arg_data):
+        repodir = params['repodir']
 
         log.info('running createrepo on %s', repodir)
 
diff --git a/libtaskotron/directives/distgit_directive.py b/libtaskotron/directives/distgit_directive.py
--- a/libtaskotron/directives/distgit_directive.py
+++ b/libtaskotron/directives/distgit_directive.py
@@ -92,43 +92,43 @@
 
         return file_utils.download(url, '.', localpath)
 
-    def process(self, input_data, env_data):
-        if 'package' not in input_data or 'path' not in input_data:
-            detected_args = ', '.join(input_data.keys())
+    def process(self, params, arg_data):
+        if 'package' not in params or 'path' not in params:
+            detected_args = ', '.join(params.keys())
             raise exc.TaskotronDirectiveError(
                 "The distgit directive requires 'package' and 'path' arguments."
                 "Detected arguments: %s" % detected_args)
 
-        if 'target_dir' not in input_data:
-            target_dir = env_data['workdir']
+        if 'target_dir' not in params:
+            target_dir = arg_data['workdir']
         else:
-            target_dir = input_data['target_dir']
+            target_dir = params['target_dir']
 
-        if not python_utils.iterable(input_data['path']):
+        if not python_utils.iterable(params['path']):
             raise exc.TaskotronValueError("Incorrect value type of the 'path' argument: "
-                                          "%s" % type(input_data['path']))
+                                          "%s" % type(params['path']))
 
-        target_path = input_data['path']
+        target_path = params['path']
         output_data = {}
 
-        if 'localpath' in input_data:
-            if not python_utils.iterable(input_data['localpath']):
+        if 'localpath' in params:
+            if not python_utils.iterable(params['localpath']):
                 raise exc.TaskotronValueError("Incorrect value type of the 'localpath' argument: "
-                                              "%s" % type(input_data['path']))
+                                              "%s" % type(params['path']))
 
-            if not len(input_data['path']) == len(input_data['localpath']):
+            if not len(params['path']) == len(params['localpath']):
                 raise exc.TaskotronValueError('path and localpath lists must be of the same '
                                               'length.')
 
-            target_path = input_data['localpath']
+            target_path = params['localpath']
 
 
         output_data['downloaded_files'] = []
-        for path, localpath in zip(input_data['path'], target_path):
+        for path, localpath in zip(params['path'], target_path):
             localpath = os.path.join(target_dir, localpath)
             file_utils.makedirs(os.path.dirname(localpath))
             output_data['downloaded_files'].append(
-                self._download_file(input_data['package'], path, localpath)
+                self._download_file(params['package'], path, localpath)
             )
 
         return output_data
diff --git a/libtaskotron/directives/dummy_directive.py b/libtaskotron/directives/dummy_directive.py
--- a/libtaskotron/directives/dummy_directive.py
+++ b/libtaskotron/directives/dummy_directive.py
@@ -52,12 +52,12 @@
 
 class DummyDirective(BaseDirective):
 
-    def process(self, input_data, env_data):
-        expected_result = input_data['result']
+    def process(self, params, arg_data):
+        expected_result = params['result']
 
         if expected_result.lower() == 'fail':
             raise TaskotronDirectiveError("This is a dummy directive and "
                                           "configured to fail")
 
-        if 'msg' in input_data:
-            return input_data['msg']
+        if 'msg' in params:
+            return params['msg']
diff --git a/libtaskotron/directives/exitcode_directive.py b/libtaskotron/directives/exitcode_directive.py
--- a/libtaskotron/directives/exitcode_directive.py
+++ b/libtaskotron/directives/exitcode_directive.py
@@ -84,33 +84,25 @@
 
 
 class ExitcodeDirective(BaseDirective):
-    def process(self, input_data, env_data):
-        """Process this directive.
-        :param dict input_data: dictionary of all kwargs from yaml declaration
-        :param dict env_data: information on the environment in which we're running
-        :returns: returncode based on YAML last or worst outcome
-        :raise TaskotronDirectiveError: ``input data`` doesn't contain exactly one of keys
-                                        ``result_last`` or ``result_last``
-        :raise TaskotronValueError: when YAML input cannot be parsed
-        """
 
+    def process(self, params, arg_data):
         # keys 'result_worst' and 'result_last' must be mutually exclusive
-        if ('result_worst' in input_data) == ('result_last' in input_data):
+        if ('result_worst' in params) == ('result_last' in params):
             raise TaskotronDirectiveError("The exitcode directive requires exactly one of keys "
                                           "'result_worst' or 'result_last'.")
 
-        if 'result_worst' in input_data:
-            details = check.import_YAML(input_data['result_worst'])
+        if 'result_worst' in params:
+            details = check.import_YAML(params['result_worst'])
             code = SUCCESS
             for detail in details:
                 if detail.outcome not in ['PASSED', 'INFO']:
                     code = FAILURE
 
             log.debug("Returning exitcode %d" % code)
             return code
 
-        elif 'result_last' in input_data:
-            details = check.import_YAML(input_data['result_last'])
+        elif 'result_last' in params:
+            details = check.import_YAML(params['result_last'])
             if details and details[-1].outcome not in ['PASSED', 'INFO']:
 
                 log.debug("Returning exitcode %d" % FAILURE)
diff --git a/libtaskotron/directives/koji_directive.py b/libtaskotron/directives/koji_directive.py
--- a/libtaskotron/directives/koji_directive.py
+++ b/libtaskotron/directives/koji_directive.py
@@ -119,73 +119,73 @@
         else:
             self.koji = koji_session
 
-    def process(self, input_data, env_data):
+    def process(self, params, arg_data):
         # process params
         valid_actions = ['download', 'download_tag', 'download_latest_stable']
-        action = input_data['action']
+        action = params['action']
         if action not in valid_actions:
             raise exc.TaskotronDirectiveError('%s is not a valid action for koji '
                                               'directive' % action)
 
-        if 'target_dir' not in input_data:
-            self.target_dir = env_data['workdir']
+        if 'target_dir' not in params:
+            self.target_dir = arg_data['workdir']
         else:
-            self.target_dir = input_data['target_dir']
+            self.target_dir = params['target_dir']
 
-        if 'arch' not in input_data:
-            detected_args = ', '.join(input_data.keys())
+        if 'arch' not in params:
+            detected_args = ', '.join(params.keys())
             raise exc.TaskotronDirectiveError(
                 "The koji directive requires 'arch' as an argument. Detected "
                 "arguments: %s" % detected_args)
 
-        self.arches = input_data['arch']
+        self.arches = params['arch']
         if self.arches and ('noarch' not in self.arches):
             self.arches.append('noarch')
 
-        self.debuginfo = input_data.get('debuginfo', False)
+        self.debuginfo = params.get('debuginfo', False)
 
-        self.src = input_data.get('src', False)
+        self.src = params.get('src', False)
 
         # download files
         output_data = {}
 
         if action == 'download':
-            if 'koji_build' not in input_data:
-                detected_args = ', '.join(input_data.keys())
+            if 'koji_build' not in params:
+                detected_args = ', '.join(params.keys())
                 raise exc.TaskotronDirectiveError(
                     "The koji directive requires 'koji_build' for the 'download' "
                     "action. Detected arguments: %s" % detected_args)
 
-            nvr = rpm_utils.rpmformat(input_data['koji_build'], 'nvr')
+            nvr = rpm_utils.rpmformat(params['koji_build'], 'nvr')
 
             output_data['downloaded_rpms'] = self.koji.get_nvr_rpms(nvr,
                                                                     self.target_dir,
                                                                     arches=self.arches,
                                                                     debuginfo=self.debuginfo,
                                                                     src=self.src)
         elif action == 'download_tag':
-            if 'koji_tag' not in input_data:
-                detected_args = ', '.join(input_data.keys())
+            if 'koji_tag' not in params:
+                detected_args = ', '.join(params.keys())
                 raise exc.TaskotronDirectiveError(
                     "The koji directive requires 'koji_tag' for the 'download_tag' "
                     "action. Detected arguments: %s" % detected_args)
 
-            koji_tag = input_data['koji_tag']
+            koji_tag = params['koji_tag']
 
             output_data['downloaded_rpms'] = self.koji.get_tagged_rpms(koji_tag,
                                                                        self.target_dir,
                                                                        arches=self.arches,
                                                                        debuginfo=self.debuginfo,
                                                                        src=self.src)
         elif action == 'download_latest_stable':
-            if 'koji_build' not in input_data:
-                detected_args = ', '.join(input_data.keys())
+            if 'koji_build' not in params:
+                detected_args = ', '.join(params.keys())
                 raise exc.TaskotronDirectiveError(
                     "The koji directive requires 'koji_build' for the 'download_latest_stable' "
                     "action. Detected arguments: %s" % detected_args)
 
-            name = rpm_utils.rpmformat(input_data['koji_build'], 'n')
-            disttag = rpm_utils.get_dist_tag(input_data['koji_build'])
+            name = rpm_utils.rpmformat(params['koji_build'], 'n')
+            disttag = rpm_utils.get_dist_tag(params['koji_build'])
             # we need to do 'fc22' -> 'f22' conversion
             tag = disttag.replace('c', '')
 
diff --git a/libtaskotron/directives/mash_directive.py b/libtaskotron/directives/mash_directive.py
--- a/libtaskotron/directives/mash_directive.py
+++ b/libtaskotron/directives/mash_directive.py
@@ -153,21 +153,21 @@
 
         return rpmdir if not outdir else outdir
 
-    def process(self, input_data, env_data):
-        if 'rpmdir' not in input_data or 'arch' not in input_data:
-            detected_args = ', '.join(input_data.keys())
+    def process(self, params, arg_data):
+        if 'rpmdir' not in params or 'arch' not in params:
+            detected_args = ', '.join(params.keys())
             raise TaskotronDirectiveError(
                 "The mash directive requires 'rpmdir' and 'arch' "
                 "arguments. Detected arguments: %s" % detected_args)
 
-        if 'dodelta' not in input_data:
+        if 'dodelta' not in params:
             dodelta = False
         else:
-            dodelta = input_data['dodelta']
+            dodelta = params['dodelta']
 
-        rpmdir = input_data['rpmdir']
-        outdir = input_data.get('outdir', None)
-        arch = input_data['arch']
+        rpmdir = params['rpmdir']
+        outdir = params.get('outdir', None)
+        arch = params['arch']
 
         # create outdir if it doesn't exist
         if outdir:
diff --git a/libtaskotron/directives/python_directive.py b/libtaskotron/directives/python_directive.py
--- a/libtaskotron/directives/python_directive.py
+++ b/libtaskotron/directives/python_directive.py
@@ -184,33 +184,22 @@
             raise TaskotronDirectiveError("The file %s does not exist!"
                                           % filename)
 
-    def process(self, input_data, env_data):
-        """Process this directive.
-        :param dict input_data: dictionary of all kwargs from yaml declaration,
-            including callable and file
-        :param dict env_data: information on the environment in which we're
-            running
-        :returns: output from the callable specified, this is expected to be YAML
-            output for checks
-        :raise TaskotronDirectiveError: if the callable returns something else
-            than ``None`` or ``basestring``
-        """
-
-        if 'callable' not in input_data or 'file' not in input_data:
-            detected_args = ', '.join(input_data.keys())
+    def process(self, params, arg_data):
+        if 'callable' not in params or 'file' not in params:
+            detected_args = ', '.join(params.keys())
             raise TaskotronDirectiveError(
                 "The python directive requires both 'callable' and 'file' "
                 "arguments. Detected arguments: %s" % detected_args)
 
-        method_name = input_data.pop('callable')
-        basedir = os.path.dirname(env_data['task'])
+        method_name = params.pop('callable')
+        basedir = os.path.dirname(arg_data['task'])
 
-        pyfile = os.path.join(basedir, input_data.pop('file'))
+        pyfile = os.path.join(basedir, params.pop('file'))
 
         self.checkfile(pyfile)
 
         _, task = self.load_pyfile(pyfile)
 
-        output = self.execute(task, method_name, input_data)
+        output = self.execute(task, method_name, params)
 
         return output
diff --git a/libtaskotron/directives/resultsdb_directive.py b/libtaskotron/directives/resultsdb_directive.py
--- a/libtaskotron/directives/resultsdb_directive.py
+++ b/libtaskotron/directives/resultsdb_directive.py
@@ -180,17 +180,14 @@
 
         return os.path.relpath(artifact_path, start=artifactsdir)
 
-    def process(self, input_data, env_data):
+    def process(self, params, arg_data):
         #TODO: Replace with proper location and adjust exc. text
         # we're creating the jobid in the directive for now, so adjust the check
 
-        if 'checkname' not in env_data:
-            raise TaskotronDirectiveError("The resultsdb directive requires checkname.")
-
         # checking if reporting is enabled is done after importing yaml which
         # serves as validation of input results
         try:
-            check_details = check.import_YAML(input_data['results'])
+            check_details = check.import_YAML(params['results'])
             log.debug("YAML output parsed OK.")
         except TaskotronValueError as e:
             raise TaskotronDirectiveError("Failed to load 'results': %s"  % e.message)
@@ -204,32 +201,32 @@
         conf = config.get_config()
         if not conf.report_to_resultsdb:
             log.info("Reporting to ResultsDB is disabled. Once enabled, the "
-                     "following would get reported:\n%s" % input_data['results'])
+                     "following would get reported:\n%s" % params['results'])
             return check.export_YAML(check_details)
 
         # for now, we're creating the resultsdb job at reporting time
         # the job needs to be 'RUNNING' in order to append any results
-        job_url, log_url = buildbot_utils.get_urls(env_data['jobid'],
+        job_url, log_url = buildbot_utils.get_urls(arg_data['jobid'],
                                                    self.masterurl,
                                                    self.task_stepname)
-        job_data = self.create_resultsdb_job(env_data['checkname'],
-                                             uuid=env_data['uuid'],
+        job_data = self.create_resultsdb_job(arg_data['checkname'],
+                                             uuid=arg_data['uuid'],
                                              )
 
         log.info('Posting %s results to ResultsDB...' % len(check_details))
         for detail in check_details:
-            checkname = detail.checkname or env_data['checkname']
+            checkname = detail.checkname or arg_data['checkname']
             self.ensure_testcase_exists(checkname)
             result_log_url = log_url
             if detail.artifact:
                 artifact_path = self.get_artifact_path(
-                    env_data['artifactsdir'],
+                    arg_data['artifactsdir'],
                     detail.artifact
                     )
                 if artifact_path:
                     result_log_url = "%s/all/%s/task_output/%s" % (
                         self.artifacts_baseurl,
-                        env_data['uuid'],
+                        arg_data['uuid'],
                         artifact_path,
                         )
             try:
diff --git a/libtaskotron/directives/yumrepoinfo_directive.py b/libtaskotron/directives/yumrepoinfo_directive.py
--- a/libtaskotron/directives/yumrepoinfo_directive.py
+++ b/libtaskotron/directives/yumrepoinfo_directive.py
@@ -118,13 +118,13 @@
                   koji_tag, output))
         return output
 
-    def process(self, input_data, env_data):
+    def process(self, params, arg_data):
 
-        if 'koji_tag' not in input_data or 'arch' not in input_data:
+        if 'koji_tag' not in params or 'arch' not in params:
             raise TaskotronDirectiveError("The yumrepoinfo directive requires "
                                           "koji_tag and arch arguments.")
 
-        arches = input_data['arch']
+        arches = params['arch']
 
         processed_arches = [arch for arch in arches if arch in Arches.base]
 
@@ -137,7 +137,7 @@
         # {'koji_tag' : {'arch' : 'URL'}}
         output = {}
         for arch in processed_arches:
-            arch_output = self.run_yumrepoinfo(arch, input_data["koji_tag"])
+            arch_output = self.run_yumrepoinfo(arch, params["koji_tag"])
             self.repoinfo = None
             for tag in arch_output:
                 output[tag] = output.get(tag, {})
diff --git a/libtaskotron/executor.py b/libtaskotron/executor.py
--- a/libtaskotron/executor.py
+++ b/libtaskotron/executor.py
@@ -28,22 +28,23 @@
 class Executor(object):
     '''This class serves the purpose of actual task execution. It is instantiated by
     :class:`.Overlord`, :class:`.PersistentMinion` or :class:`.DisposableMinion`.
-    '''
-
-    def __init__(self, task_data, arg_data, workdir=None):
-        '''Create a new instance.
 
-        :param dict task_data: data loaded from task formula
-        :param dict arg_data: data from command line arguments
-        :param str workdir: path to working directory, temporary is created if None
-        '''
+    :ivar dict formula: parsed task formula
+    :ivar dict arg_data: processed cli arguments with some extra runtime variables
+    :ivar str workdir: path to working directory; a temporary one is created during execution if
+                       ``None``
+    :ivar dict working_data: variables exported from formula directives, to be injected when
+                             referenced using ``${variable}``
+    :ivar int exitcode: exit code set by ``exitcode`` directive; it is ``None`` if ``exitcode``
+                        directive was not used
+    '''
 
-        self.task_data = task_data
+    def __init__(self, formula, arg_data, workdir=None):
+        self.formula = formula
         self.arg_data = arg_data
         self.working_data = {}
         self.directives = {}
         self.workdir = workdir
-        #: int exitcode set by exitcode directive, is None if exitcode directive was not used
         self.exitcode = None
 
     def execute(self):
@@ -60,7 +61,7 @@
         groups specified in the task formula, this method tries to install them (in case of
         production profile) or checks whether they are installed (in case of developer profile).
         '''
-        rpms = self.task_data.get('environment', {}).get('rpm', [])
+        rpms = self.formula.get('environment', {}).get('rpm', [])
         profile = config.get_config().profile
 
         if not rpm_utils.is_installed(rpms):
@@ -79,7 +80,7 @@
                                             dir=config.get_config().tmpdir)
         log.debug("Current workdir: %s", self.workdir)
         self.arg_data['workdir'] = self.workdir
-        self.arg_data['checkname'] = self.task_data['name']
+        self.arg_data['checkname'] = self.formula['name']
 
         # override variable values
         for var, val in self.arg_data['override'].items():
@@ -89,15 +90,15 @@
         self._do_actions()
 
     def _validate_input(self):
-        if 'input' not in self.task_data:
+        if 'input' not in self.formula:
             return
 
-        if not isinstance(self.task_data['input'], collections.Mapping):
+        if not isinstance(self.formula['input'], collections.Mapping):
             raise exc.TaskotronYamlError("Input yaml should contain correct 'input'"
                                          "section (a mapping). Yours was: %s" %
-                                         type(self.task_data['input']))
+                                         type(self.formula['input']))
 
-        required_args = self.task_data['input'].get('args', None)
+        required_args = self.formula['input'].get('args', None)
 
         if not python_utils.iterable(required_args):
             raise exc.TaskotronYamlError("Input yaml should contain correct 'args' "
@@ -119,11 +120,11 @@
               koji_build: $koji_build
               arch: $arch
         '''
-        if 'actions' not in self.task_data or not self.task_data['actions']:
+        if 'actions' not in self.formula or not self.formula['actions']:
             raise exc.TaskotronYamlError("At least one task should be specified"
                                          " in input formula")
 
-        for action in self.task_data['actions']:
+        for action in self.formula['actions']:
             self._do_single_action(action)
 
     def _do_single_action(self, action):
@@ -167,7 +168,7 @@
 
     def _render_action(self, action):
         '''Take an action and replace all included variables with actual values
-        from :attr:`env_data` and :attr:`working_data`. See :meth:`do_actions`
+        from :attr:`arg_data` and :attr:`working_data`. See :meth:`do_actions`
         to see how an action looks like.
 
         :param dict action: An action specification parsed from the task formula
diff --git a/libtaskotron/main.py b/libtaskotron/main.py
--- a/libtaskotron/main.py
+++ b/libtaskotron/main.py
@@ -137,6 +137,7 @@
 
 
 def main():
+    '''Main entry point executed by runtask script'''
     # Preliminary initialization of logging, so all messages before regular
     # initialization can be logged to stream.
     logger.init_prior_config()
diff --git a/libtaskotron/minion.py b/libtaskotron/minion.py
--- a/libtaskotron/minion.py
+++ b/libtaskotron/minion.py
@@ -25,30 +25,31 @@
     '''Base Minion class that shouldn't be used on its own, it solely initiates inner attributes
     and environment. It also provides method _run() that delegates the task execution to Executor
     over SSH.
+
+    :cvar tuple arg_data_exclude: a tuple of cmdline options/arguments which should not be
+        forwarded from the host to the minion when execution the task. Use the same names as the
+        stored variables in ``arg_data`` use (i.e. dashes converted to underscores, etc).
+    :ivar dict formula: parsed task formula
+    :ivar dict arg_data: processed cli arguments with some extra runtime variables
+    :ivar str artifactsdir: path to ``artifactsdir`` for storing logs
+    :ivar int exitcode: exit code of libtaskotron runner executed on the minion
+    :ivar ssh: an instance of :class:`.ParamikoWrapper` which is used to execute all remote
+        commands on a minion. ``None`` by default, you need to set this before you start
+        :meth:`execute`.
     '''
 
     arg_data_exclude = ('task', 'libvirt', 'ssh', 'ssh_privkey', 'no_destroy', 'patch')
-    '''A list of cmdline options/arguments which should not be forwarded from the host to the
-    minion when execution the task. Use the same names as the stored variables in arg_data use
-    (i.e. dashes converted to underscores, etc).'''
-
-    def __init__(self, task_data, arg_data):
-        '''Create a new instance.
 
-        :param dict task_data: data loaded from task formula
-        :param dict arg_data: data from command line arguments
-        '''
-
-        self.task_data = task_data
+    def __init__(self, formula, arg_data):
+        self.formula = formula
         self.arg_data = arg_data
-        #: str uuid_dir with path to artifactsdir for storing logs
-        self.uuid_dir = self.arg_data['artifactsdir']
+        self.artifactsdir = self.arg_data['artifactsdir']
 
         self.user = arg_data.get('user', None)
         self.machine = arg_data.get('machine', None)
         self.port = arg_data.get('port', None)
         self.ssh_privkey = arg_data['ssh_privkey'] or config.get_config().ssh_privkey
-        #: int exitcode set by exitcode directive.
+
         self.exitcode = None
         self.ssh = None
 
@@ -104,7 +105,7 @@
         # need to have default_flow_style false to get valid yaml w/ nested dicts
         self.ssh.write_file(os.path.join(self.taskdir,
                                          os.path.basename(self.arg_data['task'])),
-                            yaml.dump(self.task_data, default_flow_style=False))
+                            yaml.dump(self.formula, default_flow_style=False))
 
     def _run(self):
         '''The main method that runs the task'''
@@ -129,15 +130,15 @@
         '''copy artifacts from vm'''
         log.info('Copying task artifacts and logs from the minion...')
         try:
-            self.ssh.get_dir(self.arg_data['artifactsdir'], self.arg_data['artifactsdir'])
+            self.ssh.get_dir(self.artifactsdir, self.artifactsdir)
         except exc.TaskotronRemoteError, e:
             log.info(e)
 
     def execute(self):
         '''This method has to be implemented by classes that inherits from :class:`.BaseMinion`.
-        It should contain environment initialization, namely set `self.ssh` to properly
-        instantiated :class:`.ParamikoWrapper` and cleanup (if necessarily). Moreover, the order of
-        private methods has to be: `_prepare_task()`, `_run()` and `_get_output()`.
+        It should contain environment initialization (namely set :attr:`ssh` to properly
+        instantiated :class:`.ParamikoWrapper`) and cleanup (if necessary). Moreover, the order of
+        private methods has to be: :meth:`_prepare_task`, :meth:`_run` and :meth:`_get_output`.
         '''
         raise exc.TaskotronNotImplementedError()
 
@@ -149,10 +150,10 @@
     def execute(self):
         '''Init environment and connect to remote machine for task execution.'''
 
-        filelog_path = os.path.join(self.uuid_dir, 'taskotron-overlord.log')
+        filelog_path = os.path.join(self.artifactsdir, 'taskotron-overlord.log')
         logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
 
-        stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log')
+        stdio_filename = os.path.join(self.artifactsdir, 'taskotron-stdio.log')
 
         log.info("Running task over SSH on machine '%s'...", self.machine)
 
@@ -171,10 +172,10 @@
     def execute(self):
         '''Init environment and connect to disposable client for task execution.'''
 
-        filelog_path = os.path.join(self.uuid_dir, 'taskotron-overlord.log')
+        filelog_path = os.path.join(self.artifactsdir, 'taskotron-overlord.log')
         logger.add_filehandler(filelog_path=filelog_path, remove_mem_handler=True)
 
-        stdio_filename = os.path.join(self.uuid_dir, 'taskotron-stdio.log')
+        stdio_filename = os.path.join(self.artifactsdir, 'taskotron-stdio.log')
 
         execution_ok = False
         try:
diff --git a/libtaskotron/overlord.py b/libtaskotron/overlord.py
--- a/libtaskotron/overlord.py
+++ b/libtaskotron/overlord.py
@@ -17,24 +17,22 @@
 class Overlord(object):
     """Overlord class encapsulates decision whether the task is run locally or remotely (in
     persistent or disposable client) and orchestrates the execution.
+
+    :ivar dict arg_data: processed cli arguments with some extra runtime variables
+    :ivar int exitcode: exit code of the task; if ``None``, it means :meth:`start` was not called
+                        yet
+    :ivar dict formula: parsed task formula
     """
 
     def __init__(self, arg_data):
-        """Create new instance of Overlord.
-
-        :param dict arg_data: data from command line arguments
-        """
-
         self.arg_data = arg_data
-
-        #: int exitcode contains the exitcode of task, if None, method :func:`~Overlord.start` was
-        #: not called yet.
         self.exitcode = None
 
         # parse task formula
-        self.task_data = taskformula.parse_yaml_from_file(arg_data['task'])
-        if not self.task_data:
-            raise exc.TaskotronYamlError('Input file should not be empty')
+        self.formula = taskformula.parse_yaml_from_file(arg_data['task'])
+        if not self.formula:
+            raise exc.TaskotronYamlError('Task formula file should not be empty: %s' %
+                                         arg_data['task'])
 
     def _get_runner(self):
         """Decide the run mode and get appropriate runner (Executor or Minion).
@@ -75,11 +73,11 @@
         if run_remotely:
             from libtaskotron import minion
             if persistent:
-                return minion.PersistentMinion(self.task_data, self.arg_data)
+                return minion.PersistentMinion(self.formula, self.arg_data)
             else:
-                return minion.DisposableMinion(self.task_data, self.arg_data)
+                return minion.DisposableMinion(self.formula, self.arg_data)
         else:
-            return executor.Executor(self.task_data, self.arg_data)
+            return executor.Executor(self.formula, self.arg_data)
 
     def start(self):
         """Start the overlord, get runner and execute the task (either locally or remotely).
diff --git a/testing/functest_executor.py b/testing/functest_executor.py
--- a/testing/functest_executor.py
+++ b/testing/functest_executor.py
@@ -13,28 +13,28 @@
 
     def setup_method(self, method):
         self.ref_dir = os.path.abspath('testing/test_directives/')
-        self.ref_taskdata = {}
-        self.ref_inputdata = {'uuid': ''}
+        self.ref_formula = {}
+        self.ref_params = {'uuid': ''}
         self.ref_directivename = 'stub'
 
     def test_executor_load_directive(self, tmpdir):
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata, tmpdir)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params, tmpdir)
 
         test_executor._load_directive(self.ref_directivename, self.ref_dir)
 
         assert '%s_directive' % self.ref_directivename in sys.modules.keys()
 
     def test_executor_load_directive_indict(self, tmpdir):
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata, tmpdir)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params, tmpdir)
 
         test_executor._load_directive(self.ref_directivename, self.ref_dir)
 
         assert self.ref_directivename in test_executor.directives.keys()
 
     def test_executor_load_directive_notexist(self, tmpdir):
         self.ref_directivename = 'noexist'
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata, tmpdir)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params, tmpdir)
 
         with pytest.raises(exc.TaskotronDirectiveError):
             test_executor._load_directive(self.ref_directivename, self.ref_dir)
@@ -48,7 +48,7 @@
         stub_imp = Mock(side_effect=(ImportError("No module libtaskotron.stub")))
         monkeypatch.setattr(imp, 'load_source', stub_imp)
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata, tmpdir)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params, tmpdir)
 
         with pytest.raises(exc.TaskotronImportError) as e:
             test_executor._load_directive(self.ref_directivename, self.ref_dir)
@@ -61,7 +61,7 @@
         stub_imp = Mock(side_effect=(ImportError("No module unicorn.candy")))
         monkeypatch.setattr(imp, 'load_source', stub_imp)
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata, tmpdir)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params, tmpdir)
 
         with pytest.raises(exc.TaskotronImportError) as e:
             test_executor._load_directive(self.ref_directivename, self.ref_dir)
diff --git a/testing/functest_mash_directive.py b/testing/functest_mash_directive.py
--- a/testing/functest_mash_directive.py
+++ b/testing/functest_mash_directive.py
@@ -45,67 +45,67 @@
         os.chdir(startdir)
 
     def test_mash_arch_i686(self):
-        input_data = {
+        params = {
             'rpmdir': self.rpmdir,
             'arch': ['i386']
         }
         directive = mash_directive.MashDirective()
         before = os.listdir(self.rpmdir)
-        directive.process(input_data, {})
+        directive.process(params, {})
         after = os.listdir(self.rpmdir)
 
         assert self.rpms[0] in before and self.rpms[0] in after and \
                self.rpms[1] in before and self.rpms[1] in after
 
 
     def test_mash_arch_x86_64(self):
-        input_data = {
+        params = {
             'rpmdir': self.rpmdir,
             'arch': ['x86_64']
         }
         directive = mash_directive.MashDirective()
         before = os.listdir(self.rpmdir)
-        directive.process(input_data, {})
+        directive.process(params, {})
         after = os.listdir(self.rpmdir)
 
         assert self.rpms[0] in before and self.rpms[0] in after and \
                self.rpms[1] in before and self.rpms[1] not in after
 
     def test_outdir_is_created(self, tmpdir):
         outdir_path = tmpdir.join('somewhere/along/the/highway').strpath
-        input_data = {
+        params = {
             'rpmdir': self.rpmdir,
             'outdir': outdir_path,
             'arch': ['i386']
         }
 
         directive = mash_directive.MashDirective()
-        ret_path = directive.process(input_data, {})
+        ret_path = directive.process(params, {})
 
         assert ret_path == outdir_path
         assert os.path.isdir(ret_path)
 
 
     def test_repodata_in_rpmdir(self):
-        input_data = {
+        params = {
             'rpmdir': self.rpmdir,
             'arch': ['x86_64']
         }
         directive = mash_directive.MashDirective()
-        directive.process(input_data, {})
+        directive.process(params, {})
         after = os.listdir(self.rpmdir)
 
         assert 'repodata' in after
 
     def test_repodata_in_outdir(self, tmpdir):
         outdir = tmpdir.strpath
-        input_data = {
+        params = {
             'rpmdir': self.rpmdir,
             'outdir': outdir,
             'arch': ['x86_64']
         }
         directive = mash_directive.MashDirective()
-        directive.process(input_data, {})
+        directive.process(params, {})
         after = os.listdir(self.rpmdir)
 
         assert 'repodata' not in after and 'repodata' in os.listdir(outdir)
diff --git a/testing/test_bodhi_directive.py b/testing/test_bodhi_directive.py
--- a/testing/test_bodhi_directive.py
+++ b/testing/test_bodhi_directive.py
@@ -31,7 +31,7 @@
                           'arch': self.ref_arch,
                           'update_id': self.ref_update_id
                          }
-        self.ref_envdata = {'workdir': self.ref_workdir}
+        self.ref_arg_data = {'workdir': self.ref_workdir}
         self.ref_rpmfile = '%s/%s.rpm' % (self.ref_workdir, self.ref_nvr1)
 
         self.helper = bodhi_directive.BodhiDirective()
@@ -44,7 +44,7 @@
 
         test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
 
-        output_data = test_bodhi.process(self.ref_input, self.ref_envdata)
+        output_data = test_bodhi.process(self.ref_input, self.ref_arg_data)
 
         ref_output_data = {'downloaded_rpms': [self.ref_rpmfile,
                                                self.ref_rpmfile]}
@@ -71,7 +71,7 @@
 
         test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
 
-        test_bodhi.process(self.ref_input, self.ref_envdata)
+        test_bodhi.process(self.ref_input, self.ref_arg_data)
 
         ref_arches = set(['i386', 'x86_64', 'noarch', 'armhfp'])
         getrpms_calls = stub_koji.calls()
@@ -94,7 +94,7 @@
 
         test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
 
-        test_bodhi.process(self.ref_input, self.ref_envdata)
+        test_bodhi.process(self.ref_input, self.ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
 
@@ -115,7 +115,7 @@
 
         test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
 
-        test_bodhi.process(self.ref_input, self.ref_envdata)
+        test_bodhi.process(self.ref_input, self.ref_arg_data)
 
         getrpms_calls = stub_koji.calls()
         req_arches = map(lambda x: x[1][2], getrpms_calls)
@@ -136,7 +136,7 @@
 
         test_bodhi = bodhi_directive.BodhiDirective(stub_bodhi, stub_koji)
 
-        test_bodhi.process(self.ref_input, self.ref_envdata)
+        test_bodhi.process(self.ref_input, self.ref_arg_data)
 
         getrpms_calls = stub_koji.calls()
         req_arches = map(lambda x: x[1][2], getrpms_calls)
@@ -154,7 +154,7 @@
 
         # No update is found, b. directive should raise an Exception
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(self.ref_input, self.ref_envdata)
+            test_bodhi.process(self.ref_input, self.ref_arg_data)
 
 
     def test_invalid_action(self):
@@ -169,10 +169,9 @@
 
         # Unknown action should raise an Exception
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(self.ref_input, self.ref_envdata)
+            test_bodhi.process(self.ref_input, self.ref_arg_data)
 
-
-    def test_action_download_insufficient_input_data(self):
+    def test_action_download_insufficient_params(self):
         '''Test response on unsufficient input for download action'''
         ref_input = {'action': 'download'}
 
@@ -183,16 +182,16 @@
 
         # Tests with no information
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(ref_input, self.ref_envdata)
+            test_bodhi.process(ref_input, self.ref_arg_data)
 
         ref_input['arch'] = self.ref_arch
 
         # Tests with only arch, or update_id given
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(ref_input, self.ref_envdata)
+            test_bodhi.process(ref_input, self.ref_arg_data)
 
         ref_input.pop('arch')
         ref_input['update_id'] = self.ref_update_id
 
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(ref_input, self.ref_envdata)
+            test_bodhi.process(ref_input, self.ref_arg_data)
diff --git a/testing/test_create_report_directive.py b/testing/test_create_report_directive.py
--- a/testing/test_create_report_directive.py
+++ b/testing/test_create_report_directive.py
@@ -30,7 +30,7 @@
         self.yaml = check.export_YAML(self.cd)
 
         self.ref_input = {'results': self.yaml}
-        self.ref_envdata = {
+        self.ref_arg_data = {
             'resultsdb_job_id': 1,
             'checkname': 'test_resultsdb_report',
             'jobid': 'all/123',
@@ -45,4 +45,4 @@
         monkeypatch.setattr(check, 'import_YAML', import_YAML)
 
         with pytest.raises(TaskotronDirectiveError):
-            self.rd.process(self.ref_input, self.ref_envdata)
+            self.rd.process(self.ref_input, self.ref_arg_data)
diff --git a/testing/test_directives/stub_directive.py b/testing/test_directives/stub_directive.py
--- a/testing/test_directives/stub_directive.py
+++ b/testing/test_directives/stub_directive.py
@@ -6,5 +6,5 @@
 from libtaskotron.directives import BaseDirective
 
 class StubDirective(BaseDirective):
-    def process(self, command, input_data, env_data):
+    def process(self, command, params, arg_data):
         return "this is just a stub"
diff --git a/testing/test_distgit_directive.py b/testing/test_distgit_directive.py
--- a/testing/test_distgit_directive.py
+++ b/testing/test_distgit_directive.py
@@ -18,7 +18,7 @@
         self.ref_path = ['foo.spec']
         self.ref_localpath = ['local.foo.spec']
         self.ref_branch = 'f99'
-        self.ref_envdata = {'workdir': '/var/tmp/foo'}
+        self.ref_arg_data = {'workdir': '/var/tmp/foo'}
         self.helper = distgit_directive.DistGitDirective()
 
     def _get_url(self, path):
@@ -31,13 +31,14 @@
 
         monkeypatch.setattr(file_utils, 'download', Dingus())
 
-        self.helper.process(ref_input, self.ref_envdata)
+        self.helper.process(ref_input, self.ref_arg_data)
 
         download_calls = file_utils.download.calls
 
         assert len(download_calls) == 1
         assert download_calls[0][1][0] == self._get_url(self.ref_path[0])
-        assert download_calls[0][1][2] == os.path.join(self.ref_envdata['workdir'], self.ref_path[0])
+        assert download_calls[0][1][2] == os.path.join(self.ref_arg_data['workdir'],
+                                                       self.ref_path[0])
 
     def test_parse_download_command_localpath(self, monkeypatch):
         ref_input = {'action': 'download',
@@ -47,13 +48,14 @@
 
         monkeypatch.setattr(file_utils, 'download', Dingus())
 
-        self.helper.process(ref_input, self.ref_envdata)
+        self.helper.process(ref_input, self.ref_arg_data)
 
         download_calls = file_utils.download.calls
 
         assert len(download_calls) == 1
         assert download_calls[0][1][0] == self._get_url(self.ref_path[0])
-        assert download_calls[0][1][2] == os.path.join(self.ref_envdata['workdir'], self.ref_localpath[0])
+        assert download_calls[0][1][2] == os.path.join(self.ref_arg_data['workdir'],
+                                                       self.ref_localpath[0])
 
     def test_parse_download_command_multiple_localpath(self, monkeypatch):
         ref_path = ['file1', 'file2']
@@ -65,15 +67,17 @@
 
         monkeypatch.setattr(file_utils, 'download', Dingus())
 
-        self.helper.process(ref_input, self.ref_envdata)
+        self.helper.process(ref_input, self.ref_arg_data)
 
         download_calls = file_utils.download.calls
 
         assert len(download_calls) == 2
         assert download_calls[0][1][0] == self._get_url(ref_path[0])
         assert download_calls[1][1][0] == self._get_url(ref_path[1])
-        assert download_calls[0][1][2] == os.path.join(self.ref_envdata['workdir'], ref_localpath[0])
-        assert download_calls[1][1][2] == os.path.join(self.ref_envdata['workdir'], ref_localpath[1])
+        assert download_calls[0][1][2] == os.path.join(self.ref_arg_data['workdir'],
+                                                       ref_localpath[0])
+        assert download_calls[1][1][2] == os.path.join(self.ref_arg_data['workdir'],
+                                                       ref_localpath[1])
 
     def test_parse_download_command_incorrect_localpath(self):
         ref_path = ['file1', 'file2']
@@ -84,16 +88,16 @@
                      'localpath': ref_localpath}
 
         with pytest.raises(exc.TaskotronValueError):
-            self.helper.process(ref_input, self.ref_envdata)
+            self.helper.process(ref_input, self.ref_arg_data)
 
     def test_parse_download_command_incorrect_path_str(self):
         ref_path = 'file1'
         ref_input = {'action': 'download',
                      'package': self.ref_nvr,
                      'path': ref_path}
 
         with pytest.raises(exc.TaskotronValueError):
-            self.helper.process(ref_input, self.ref_envdata)
+            self.helper.process(ref_input, self.ref_arg_data)
 
     def test_parse_download_command_incorrect_localpath_str(self):
         ref_localpath = 'file2'
@@ -103,18 +107,18 @@
                      'localpath': ref_localpath}
 
         with pytest.raises(exc.TaskotronValueError):
-            self.helper.process(ref_input, self.ref_envdata)
+            self.helper.process(ref_input, self.ref_arg_data)
 
     def test_parse_download_command_missing_package(self):
         ref_input = {'action': 'download',
                      'path': self.ref_path}
 
         with pytest.raises(exc.TaskotronDirectiveError):
-            self.helper.process(ref_input, self.ref_envdata)
+            self.helper.process(ref_input, self.ref_arg_data)
 
     def test_parse_download_command_missing_path(self):
         ref_input = {'action': 'download',
                      'package': self.ref_nvr}
 
         with pytest.raises(exc.TaskotronDirectiveError):
-            self.helper.process(ref_input, self.ref_envdata)
+            self.helper.process(ref_input, self.ref_arg_data)
diff --git a/testing/test_executor.py b/testing/test_executor.py
--- a/testing/test_executor.py
+++ b/testing/test_executor.py
@@ -17,13 +17,13 @@
 class TestExecutorInputVerify():
     def test_yamlexecutor_valid_input(self):
         ref_cmd = '-i foo-1.2-3.fc99 -t koji_build -a x86_64 footask.yml'
-        ref_argdata = {'input': {'args': ['koji_build', 'arch']}, 'uuid': ''}
+        ref_arg_data = {'input': {'args': ['koji_build', 'arch']}, 'uuid': ''}
 
         test_parser = main.get_argparser()
         test_input_args = vars(test_parser.parse_args(ref_cmd.split()))
         test_args = main.process_args(test_input_args)
 
-        test_executor = executor.Executor(ref_argdata, test_args)
+        test_executor = executor.Executor(ref_arg_data, test_args)
 
         test_executor._validate_input()
 
@@ -107,23 +107,23 @@
 
 class TestExecutorSetup():
     def test_trivial_creation(self, tmpdir):
-        ref_taskdata = {'preparation': {'koji': 'download nvr'},
-                        'input': {'args': ['koji_build', 'arch']},
-                        'post': {'shell': 'clean'},
-                        'execution': {'python': 'run_rpmlint.py'},
-                        'dependencies': ['rpmlint', 'libtaskbot']}
-        ref_inputdata = {'uuid': ''}
+        ref_formula = {'preparation': {'koji': 'download nvr'},
+                       'input': {'args': ['koji_build', 'arch']},
+                       'post': {'shell': 'clean'},
+                       'execution': {'python': 'run_rpmlint.py'},
+                       'dependencies': ['rpmlint', 'libtaskbot']}
+        ref_params = {'uuid': ''}
 
-        test_executor = executor.Executor(ref_taskdata, ref_inputdata, tmpdir)
+        test_executor = executor.Executor(ref_formula, ref_params, tmpdir)
 
-        assert test_executor.task_data == ref_taskdata
+        assert test_executor.formula == ref_formula
 
 
 class TestExecutorSingleAction():
 
     def setup_method(self, method):
-        self.ref_taskdata = {}
-        self.ref_inputdata = {'uuid': ''}
+        self.ref_formula = {}
+        self.ref_params = {'uuid': ''}
 
         self.ref_yaml_passed = """
 results:
@@ -142,7 +142,7 @@
                       ref_directivename: {'result': 'pass',
                                           'msg': 'dummy message'}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_directivename = test_executor._extract_directive_from_action(
             ref_action)
@@ -153,15 +153,15 @@
         ref_action = {'dummy': {'result': 'pass'}}
         ref_action.update({'name': 'Dummy Action'})
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_executor._do_single_action(ref_action)
 
     def test_executor_single_dummy_action_fail(self):
         ref_action = {'name': 'Dummy Action',
                       'dummy': {'result': 'fail'}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         with pytest.raises(exc.TaskotronDirectiveError):
             test_executor._do_single_action(ref_action)
@@ -173,7 +173,7 @@
                       'dummy': {'result': 'pass', 'msg': ref_output},
                       'export': '%s' % ref_exportname}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_executor._do_single_action(ref_action)
 
@@ -188,7 +188,7 @@
                                 'msg': '${%s}' % ref_messagename},
                       'export': '%s' % ref_exportname}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.working_data[ref_messagename] = ref_message
 
         test_executor._do_single_action(ref_action)
@@ -198,43 +198,43 @@
     def test_executor_do_single_dummy_action_exitcode_None(self):
         ref_action = {'name': 'Return exitcode', 'exitcode': {'result_last': self.ref_yaml_passed}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_executor._do_single_action(ref_action)
 
         assert test_executor.exitcode == exitcode_directive.SUCCESS
 
     def test_executor_do_single_dummy_action_exitcode_success(self):
         ref_action = {'name': 'Return exitcode', 'exitcode': {'result_last': self.ref_yaml_passed}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_executor._do_single_action(ref_action)
 
         assert test_executor.exitcode == exitcode_directive.SUCCESS
 
     def test_executor_do_single_dummy_action_exitcode_failure(self):
         ref_action = {'name': 'Return exitcode', 'exitcode': {'result_last': self.ref_yaml_failed}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_executor._do_single_action(ref_action)
 
         assert test_executor.exitcode == exitcode_directive.FAILURE
 
     def test_executor_do_single_dummy_action_exitcode_failure_overwrite_success(self):
         ref_action = {'name': 'Return exitcode', 'exitcode': {'result_last': self.ref_yaml_failed}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.exitcode = exitcode_directive.SUCCESS
         test_executor._do_single_action(ref_action)
 
         assert test_executor.exitcode == exitcode_directive.FAILURE
 
     def test_executor_do_single_dummy_action_exitcode_success_not_overwrite_failure(self):
         ref_action = {'name': 'Return exitcode', 'exitcode': {'result_last': self.ref_yaml_passed}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.exitcode = exitcode_directive.FAILURE
         test_executor._do_single_action(ref_action)
 
@@ -244,34 +244,34 @@
 class TestExecutorDoActions():
 
     def setup_method(self, method):
-        self.ref_taskdata = {}
-        self.ref_inputdata = {'uuid': ''}
+        self.ref_formula = {}
+        self.ref_params = {'uuid': ''}
 
     def test_executor_do_single_dummy_pass(self):
         ref_action = {'name': 'Dummy Action',
                       'dummy': {'result': 'pass'}}
-        self.ref_taskdata = {'actions': [ref_action]}
+        self.ref_formula = {'actions': [ref_action]}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         test_executor._do_actions()
 
     def test_executor_do_single_dummy_fail(self):
         ref_action = {'name': 'Dummy Action',
                       'dummy': {'result': 'fail'}}
-        self.ref_taskdata = {'actions': [ref_action]}
+        self.ref_formula = {'actions': [ref_action]}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         with pytest.raises(exc.TaskotronDirectiveError):
             test_executor._do_actions()
 
     def test_executor_do_multiple_dummy_fail(self):
         ref_action = {'name': 'Dummy Action',
                       'dummy': {'result': 'fail'}}
-        self.ref_taskdata = {'actions': [ref_action, ref_action]}
+        self.ref_formula = {'actions': [ref_action, ref_action]}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         with pytest.raises(exc.TaskotronDirectiveError):
             test_executor._do_actions()
@@ -285,45 +285,45 @@
                                 'msg': '${%s}' % ref_messagename},
                       'export': '%s' % ref_exportname}
 
-        self.ref_taskdata = {'actions': [ref_action, ref_action]}
+        self.ref_formula = {'actions': [ref_action, ref_action]}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.working_data[ref_messagename] = ref_message
 
         test_executor._do_actions()
 
         assert test_executor.working_data[ref_exportname] == ref_message
 
     def test_executor_fails_missing_action(self):
-        self.ref_taskdata = {'actions': None}
+        self.ref_formula = {'actions': None}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         with pytest.raises(exc.TaskotronYamlError):
             test_executor._do_actions()
 
     def test_executor_fails_missing_task(self):
-        self.ref_taskdata = {}
+        self.ref_formula = {}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
 
         with pytest.raises(exc.TaskotronYamlError):
             test_executor._do_actions()
 
 
 class TestExecutorRenderAction():
 
     def setup_method(self, method):
-        self.ref_taskdata = {}
-        self.ref_inputdata = {'uuid': ''}
+        self.ref_formula = {}
+        self.ref_params = {'uuid': ''}
 
     def test_executor_render_single_variable(self):
         ref_message = 'This is a variable message'
         ref_messagename = 'variable_messsage'
         ref_action = {'name': 'test dummy action', 'dummy':
                       {'result': 'pass', 'msg': '${%s}' % ref_messagename}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.working_data[ref_messagename] = ref_message
 
         test_rendered_action = test_executor._render_action(ref_action)
@@ -336,7 +336,7 @@
         ref_action = {'name': 'test dummy action', 'dummy':
                       {'result': 'pass', 'msg': '${%s}' % ref_varname}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.working_data[ref_varname] = ref_var
 
         test_rendered_action = test_executor._render_action(ref_action)
@@ -352,7 +352,7 @@
                       {'result': 'pass', 'msg': '--foo ${%s} --bar ${%s}' %
                        (ref_var1name, ref_var2name)}}
 
-        test_executor = executor.Executor(self.ref_taskdata, self.ref_inputdata)
+        test_executor = executor.Executor(self.ref_formula, self.ref_params)
         test_executor.working_data[ref_var1name] = ref_var1
         test_executor.working_data[ref_var2name] = ref_var2
 
@@ -377,19 +377,19 @@
                           'task': 'task.yaml'}
 
     def test_override_existing(self):
-        ref_inputdata = main.process_args(self.ref_input)
+        ref_params = main.process_args(self.ref_input)
 
-        test_executor = executor.Executor(Dingus(), ref_inputdata)
+        test_executor = executor.Executor(Dingus(), ref_params)
         test_executor._do_actions = lambda: None
         test_executor._run()
 
         assert test_executor.arg_data['workdir'] == "/some/dir/"
 
     def test_override_nonexisting(self):
         self.ref_input['override'] = ["friendship='is magic'"]
-        ref_inputdata = main.process_args(self.ref_input)
+        ref_params = main.process_args(self.ref_input)
 
-        test_executor = executor.Executor(Dingus(), ref_inputdata)
+        test_executor = executor.Executor(Dingus(), ref_params)
         test_executor._do_actions = lambda: None
         test_executor._run()
 
diff --git a/testing/test_exitcode_directive.py b/testing/test_exitcode_directive.py
--- a/testing/test_exitcode_directive.py
+++ b/testing/test_exitcode_directive.py
@@ -17,8 +17,8 @@
 
     @pytest.fixture
     def setup(self):
-        self.test_env_data = {}
-        self.test_input_data = {}
+        self.test_arg_data = {}
+        self.test_params = {}
         self.test_yaml = """
 results:
   - item: Hello World P
@@ -32,41 +32,41 @@
 """
 
     def test_result_last(self):
-        self.test_input_data['result_last'] = self.test_yaml
-        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_input_data,
-                                                                  self.test_env_data)
+        self.test_params['result_last'] = self.test_yaml
+        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_params,
+                                                                  self.test_arg_data)
         assert exitcode == exitcode_directive.SUCCESS
 
     def test_result_worst(self):
-        self.test_input_data['result_worst'] = self.test_yaml
-        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_input_data,
-                                                                  self.test_env_data)
+        self.test_params['result_worst'] = self.test_yaml
+        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_params,
+                                                                  self.test_arg_data)
         assert exitcode == exitcode_directive.FAILURE
 
     def test_bad_input(self):
         with pytest.raises(TaskotronDirectiveError):
-            exitcode_directive.ExitcodeDirective().process(self.test_input_data,
-                                                           self.test_env_data)
+            exitcode_directive.ExitcodeDirective().process(self.test_params,
+                                                           self.test_arg_data)
 
     def test_bad_yaml(self):
         self.test_yaml = "key:value\nkey2: value"
-        self.test_input_data['result_worst'] = self.test_yaml
+        self.test_params['result_worst'] = self.test_yaml
         with pytest.raises(TaskotronValueError):
-            exitcode_directive.ExitcodeDirective().process(self.test_input_data,
-                                                           self.test_env_data)
+            exitcode_directive.ExitcodeDirective().process(self.test_params,
+                                                           self.test_arg_data)
 
     def test_empty_result_worst(self):
         self.test_yaml = "{results:[]}"
-        self.test_input_data['result_worst'] = self.test_yaml
-        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_input_data,
-                                                                  self.test_env_data)
+        self.test_params['result_worst'] = self.test_yaml
+        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_params,
+                                                                  self.test_arg_data)
         assert exitcode == exitcode_directive.SUCCESS
 
     def test_empty_result_last(self):
         self.test_yaml = "{results:[]}"
-        self.test_input_data['result_last'] = self.test_yaml
-        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_input_data,
-                                                                  self.test_env_data)
+        self.test_params['result_last'] = self.test_yaml
+        exitcode = exitcode_directive.ExitcodeDirective().process(self.test_params,
+                                                                  self.test_arg_data)
         assert exitcode == exitcode_directive.SUCCESS
 
 
diff --git a/testing/test_koji_directive.py b/testing/test_koji_directive.py
--- a/testing/test_koji_directive.py
+++ b/testing/test_koji_directive.py
@@ -36,7 +36,7 @@
                        % self.ref_nvr
         self.helper = koji_directive.KojiDirective()
 
-        self.ref_envdata = {'workdir': '/var/tmp/foo'}
+        self.ref_arg_data = {'workdir': '/var/tmp/foo'}
 
         self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
                          % (self.ref_nvr, self.ref_arch)]
@@ -51,7 +51,7 @@
 
         test_helper = koji_directive.KojiDirective(stub_koji)
 
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input, self.ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
         requested_nvr = getrpm_calls[0][1][0]
@@ -73,7 +73,7 @@
 
         test_helper = koji_directive.KojiDirective(stub_koji)
 
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input, self.ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
         requested_tag = getrpm_calls[0][1][0]
@@ -92,7 +92,7 @@
 
         test_helper = koji_directive.KojiDirective(stub_koji)
 
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input, self.ref_arg_data)
 
         koji_calls = stub_koji.calls()
 
@@ -116,7 +116,7 @@
         stub_koji = Dingus('koji_utils')
 
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input, self.ref_arg_data)
 
         assert test_helper.arches == self.ref_arch
 
@@ -128,18 +128,18 @@
         stub_koji = Dingus('koji_utils')
 
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input, self.ref_arg_data)
 
         assert test_helper.arches == self.ref_arch
 
     def test_add_noarch_download_command(self):
         ref_input = {'action': 'download', 'arch': ['x86_64'],
                      'koji_build': self.ref_nvr}
-        ref_envdata = {'workdir': '/var/tmp/foo'}
+        ref_arg_data = {'workdir': '/var/tmp/foo'}
 
         stub_koji = Dingus()
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(ref_input, ref_envdata)
+        test_helper.process(ref_input, ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
         requested_arches = getrpm_calls[0][2]['arches']
@@ -151,11 +151,11 @@
     def test_add_noarch_download_tag_command(self):
         ref_input = {'action': 'download_tag', 'arch': ['x86_64'],
                      'koji_tag': self.ref_tag}
-        ref_envdata = {'workdir': '/var/tmp/foo'}
+        ref_arg_data = {'workdir': '/var/tmp/foo'}
 
         stub_koji = Dingus(get_tagged_rpms__returns=self.ref_rpms)
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(ref_input, ref_envdata)
+        test_helper.process(ref_input, ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
         requested_arches = getrpm_calls[0][2]['arches']
@@ -167,11 +167,11 @@
     def test_download_command_src(self):
         ref_input = {'action': 'download', 'arch': [], 'src': True,
                      'koji_build': self.ref_nvr}
-        ref_envdata = {'workdir': '/var/tmp/foo'}
+        ref_arg_data = {'workdir': '/var/tmp/foo'}
 
         stub_koji = Dingus()
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(ref_input, ref_envdata)
+        test_helper.process(ref_input, ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
         requested_arches = getrpm_calls[0][2]['arches']
@@ -184,11 +184,11 @@
     def test_download_command_debuginfo(self):
         ref_input = {'action': 'download', 'arch': [], 'debuginfo': True,
                      'koji_build': self.ref_nvr}
-        ref_envdata = {'workdir': '/var/tmp/foo'}
+        ref_arg_data = {'workdir': '/var/tmp/foo'}
 
         stub_koji = Dingus()
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(ref_input, ref_envdata)
+        test_helper.process(ref_input, ref_arg_data)
 
         getrpm_calls = stub_koji.calls()
         requested_arches = getrpm_calls[0][2]['arches']
diff --git a/testing/test_main.py b/testing/test_main.py
--- a/testing/test_main.py
+++ b/testing/test_main.py
@@ -116,42 +116,42 @@
 
     def test_runmode_exclusive(self):
         '''allow only single runmode selection'''
-        ref_inputdata_bad = [{'local': True, 'ssh': 'user@machine'},
-                             {'local': True, 'libvirt': True},
-                             {'libvirt': True, 'ssh': 'user@machine'},
-                             {'local': True, 'ssh': 'user@machine', 'libvirt': True}]
-        ref_inputdata_good = [{'local': True},
-                              {'ssh': 'user@machine'},
-                              {'libvirt': True},
-                              {}]
-
-        for ref_inputdata in ref_inputdata_bad:
+        ref_params_bad = [{'local': True, 'ssh': 'user@machine'},
+                          {'local': True, 'libvirt': True},
+                          {'libvirt': True, 'ssh': 'user@machine'},
+                          {'local': True, 'ssh': 'user@machine', 'libvirt': True}]
+        ref_params_good = [{'local': True},
+                           {'ssh': 'user@machine'},
+                           {'libvirt': True},
+                           {}]
+
+        for ref_params in ref_params_bad:
             stub_error = Dingus()
             stub_parser = Dingus()
             stub_parser.error = stub_error
             args = self.empty_args.copy()
-            args.update(ref_inputdata)
+            args.update(ref_params)
             main.check_args(stub_parser, args)
             assert len(stub_error.calls()) == 1
 
-        for ref_inputdata in ref_inputdata_good:
+        for ref_params in ref_params_good:
             stub_error = Dingus()
             stub_parser = Dingus()
             stub_parser.error = stub_error
             args = self.empty_args.copy()
-            args.update(ref_inputdata)
+            args.update(ref_params)
             main.check_args(stub_parser, args)
             assert len(stub_error.calls()) == 0
 
     def test_ssh_bad_usermachine(self):
         '''fail on invalid user@machine[:port] specifier'''
-        ref_inputdata = {'ssh': 'user#machine'}
+        ref_params = {'ssh': 'user#machine'}
 
         stub_error = Dingus()
         stub_parser = Dingus()
         stub_parser.error = stub_error
         args = self.empty_args
-        args.update(ref_inputdata)
+        args.update(ref_params)
         main.check_args(stub_parser, args)
 
         assert len(stub_error.calls()) == 1
diff --git a/testing/test_overlord.py b/testing/test_overlord.py
--- a/testing/test_overlord.py
+++ b/testing/test_overlord.py
@@ -22,7 +22,6 @@
         self.stub_local = Dingus()
         self.stub_remote = Dingus()
         self.stub_remote_persistent = Dingus()
-        self.uuid_dir = '/something/totally/random'
         monkeypatch.setattr(taskformula, 'parse_yaml_from_file', Dingus())
         monkeypatch.setattr(file_utils, 'makedirs', Dingus())
 
@@ -38,70 +37,69 @@
 
         self.empty_args = {'local': None, 'libvirt': None, 'ssh': None, 'ssh_privkey': None,
                            'uuid': '', 'task': '', 'artifactsdir': '/dir'}
-        self.fake_taskdata = {'environment': {'rpm': ['foo', 'bar']}}
 
     def test_local_no_cli(self, monkeypatch):
         '''run locally with local runmode in config and no override from cli'''
-        ref_inputdata = self.empty_args.copy()
+        ref_params = self.empty_args.copy()
         self.stub_get_config.return_value = self.stub_config_local
         monkeypatch.setattr(config, 'get_config', self.stub_get_config)
 
-        test_runner = overlord.Overlord(ref_inputdata)
+        test_runner = overlord.Overlord(ref_params)
 
         test_runner.start()
         assert len(self.stub_local.calls()) == 1
         assert len(self.stub_remote.calls()) == 0
         assert len(self.stub_remote_persistent.calls()) == 0
 
     def test_remote_no_cli(self, monkeypatch):
         '''run remotely with remote runmode in config and no override from cli'''
-        ref_inputdata = self.empty_args.copy()
+        ref_params = self.empty_args.copy()
         self.stub_get_config.return_value = self.stub_config_remote
         monkeypatch.setattr(config, 'get_config', self.stub_get_config)
 
-        test_runner = overlord.Overlord(ref_inputdata)
+        test_runner = overlord.Overlord(ref_params)
 
         test_runner.start()
         assert len(self.stub_local.calls()) == 0
         assert len(self.stub_remote.calls()) == 1
         assert len(self.stub_remote_persistent.calls()) == 0
 
     def test_remote_override_local(self, monkeypatch):
         '''run locally with remote runmode in config and local override from cli'''
-        ref_inputdata = self.empty_args.copy()
-        ref_inputdata.update({'local': True})
+        ref_params = self.empty_args.copy()
+        ref_params.update({'local': True})
         self.stub_get_config.return_value = self.stub_config_remote
         monkeypatch.setattr(config, 'get_config', self.stub_get_config)
 
-        test_runner = overlord.Overlord(ref_inputdata)
+        test_runner = overlord.Overlord(ref_params)
 
         test_runner.start()
         assert len(self.stub_local.calls()) == 1
         assert len(self.stub_remote.calls()) == 0
         assert len(self.stub_remote_persistent.calls()) == 0
 
     def test_local_override_ssh(self, monkeypatch):
         '''run remotely with local runmode in config and ssh override from cli'''
-        ref_inputdata = self.empty_args.copy()
-        ref_inputdata.update({'ssh': 'david@HAL9000'})
+        ref_params = self.empty_args.copy()
+        ref_params.update({'ssh': 'david@HAL9000'})
         self.stub_get_config.return_value = self.stub_config_local
         monkeypatch.setattr(config, 'get_config', self.stub_get_config)
 
-        test_runner = overlord.Overlord(ref_inputdata)
+        test_runner = overlord.Overlord(ref_params)
 
         test_runner.start()
         assert len(self.stub_local.calls()) == 0
         assert len(self.stub_remote.calls()) == 0
         assert len(self.stub_remote_persistent.calls()) == 1
 
     def test_local_override_libvirt(self, monkeypatch):
         '''run remotely with local runmode in config and libvirt override from cli'''
-        ref_inputdata = self.empty_args.copy()
-        ref_inputdata.update({'libvirt': True})
+        ref_params = self.empty_args.copy()
+        ref_params.update({'libvirt': True})
         self.stub_get_config.return_value = self.stub_config_local
         monkeypatch.setattr(config, 'get_config', self.stub_get_config)
 
-        test_runner = overlord.Overlord(ref_inputdata)
+        test_runner = overlord.Overlord(ref_params)
 
         test_runner.start()
         assert len(self.stub_local.calls()) == 0
@@ -112,13 +110,13 @@
         monkeypatch.setattr(taskformula, 'parse_yaml_from_file', Dingus())
         monkeypatch.setattr(file_utils, 'makedirs', Dingus())
 
-        ref_inputdata = {'local': True, 'ssh': None, 'ssh_privkey': None, 'uuid': '',
+        ref_params = {'local': True, 'ssh': None, 'ssh_privkey': None, 'uuid': '',
                          'task': '', 'artifactsdir': '/dir'}
 
         stub_local_runner = Dingus()
         monkeypatch.setattr(executor, 'Executor', stub_local_runner)
 
-        test_runner = overlord.Overlord(ref_inputdata)
+        test_runner = overlord.Overlord(ref_params)
 
         test_runner.start()
 
diff --git a/testing/test_resultsdb_directive.py b/testing/test_resultsdb_directive.py
--- a/testing/test_resultsdb_directive.py
+++ b/testing/test_resultsdb_directive.py
@@ -7,7 +7,6 @@
 
 import os
 import pytest
-from copy import deepcopy
 from dingus import Dingus, exception_raiser
 
 from libtaskotron.directives import resultsdb_directive
@@ -38,7 +37,7 @@
         self.yaml = check.export_YAML(self.cd)
 
         self.ref_input = {'results': self.yaml}
-        self.ref_envdata = {
+        self.ref_arg_data = {
                 'resultsdb_job_id': 1,
                 'checkname': 'test_resultsdb_report',
                 'jobid': 'all/123',
@@ -49,16 +48,16 @@
         self.ref_resultdata = {u'id': 1234}
 
         self.ref_jobid = 1234
-        self.ref_refurl = u'http://example.com/%s' % self.ref_envdata['checkname']
-        self.ref_jobdata = { u'end_time': None,
-                        u'href': u'http://127.0.0.1/api/v1.0/jobs/%d' % self.ref_jobid,
-                        u'id': self.ref_jobid,
-                        u'name': self.ref_envdata['checkname'],
-                        u'ref_url': self.ref_refurl,
-                        u'results': [],
-                        u'results_count': 0,
-                        u'start_time': None,
-                        u'status': u'SCHEDULED'}
+        self.ref_refurl = u'http://example.com/%s' % self.ref_arg_data['checkname']
+        self.ref_jobdata = {u'end_time': None,
+                            u'href': u'http://127.0.0.1/api/v1.0/jobs/%d' % self.ref_jobid,
+                            u'id': self.ref_jobid,
+                            u'name': self.ref_arg_data['checkname'],
+                            u'ref_url': self.ref_refurl,
+                            u'results': [],
+                            u'results_count': 0,
+                            u'start_time': None,
+                            u'status': u'SCHEDULED'}
 
         self.stub_rdb = Dingus('resultsdb', get_testcase__returns={},
                                create_job__returns=self.ref_jobdata,
@@ -78,7 +77,7 @@
 
         conf.report_to_resultsdb = False
 
-        yaml = self.test_rdb.process(self.ref_input, self.ref_envdata)
+        yaml = self.test_rdb.process(self.ref_input, self.ref_arg_data)
         cds = check.import_YAML(yaml)
         my_cd = check.import_YAML(check.export_YAML(self.cd))
         # return value should be the same YAML
@@ -90,21 +89,14 @@
 
         config._config = None
 
-    def test_missing_checkname(self):
-        """Checks if missing checkname raises exception"""
-        with pytest.raises(TaskotronDirectiveError):
-            envdata = deepcopy(self.ref_envdata)
-            del(envdata['checkname'])
-
-            self.test_rdb.process(self.ref_input, envdata)
 
     def test_failed_yaml_import(self, monkeypatch):
         """Checks if failed YAML import raises exception"""
         monkeypatch.setattr(check, 'import_YAML',
                             exception_raiser(TaskotronValueError("Testing Error")))
 
         with pytest.raises(TaskotronDirectiveError):
-            self.test_rdb.process(self.ref_input, self.ref_envdata)
+            self.test_rdb.process(self.ref_input, self.ref_arg_data)
 
     def test_yaml_missing_item(self):
         """Checks if missing item raises exception"""
@@ -115,7 +107,7 @@
             yaml += line + '\n'
 
         with pytest.raises(TaskotronDirectiveError):
-            self.test_rdb.process({"results": yaml}, self.ref_envdata)
+            self.test_rdb.process({"results": yaml}, self.ref_arg_data)
 
     def test_yaml_missing_type(self):
         """Checks if missing type raises exception"""
@@ -126,13 +118,13 @@
             yaml += line + '\n'
 
         with pytest.raises(TaskotronDirectiveError):
-            self.test_rdb.process({"results": yaml}, self.ref_envdata)
+            self.test_rdb.process({"results": yaml}, self.ref_arg_data)
 
     def test_report(self):
         """Checks whether YAML is correctly mapped to the reporting method's
         arguments."""
 
-        self.test_rdb.process(self.ref_input, self.ref_envdata)
+        self.test_rdb.process(self.ref_input, self.ref_arg_data)
 
         # Given the input data, the resultsdb should be called once, and only
         #   once, calling "create_result".
@@ -152,14 +144,14 @@
         # Select the keyword arguments of that call
         call_data = call[2]
 
-        # the log url depends on the env_data, so construct it here
-        ref_builder, ref_jobid = self.ref_envdata['jobid'].split('/')
+        # the log url depends on the arg_data, so construct it here
+        ref_builder, ref_jobid = self.ref_arg_data['jobid'].split('/')
         ref_log_url = '%s/builders/%s/builds/%s/steps/%s/logs/stdio' %\
                       (self.conf.taskotron_master, ref_builder, ref_jobid,
                        self.conf.buildbot_task_step)
 
         assert call_data['job_id'] == self.ref_jobid
-        assert call_data['testcase_name'] == self.ref_envdata['checkname']
+        assert call_data['testcase_name'] == self.ref_arg_data['checkname']
         assert call_data['outcome'] == self.cd.outcome
         assert call_data['summary'] == self.cd.note
         assert call_data['log_url'] == ref_log_url
@@ -208,7 +200,7 @@
         yaml = check.export_YAML(cd)
         ref_input = {'results': yaml}
 
-        self.test_rdb.process(ref_input, self.ref_envdata)
+        self.test_rdb.process(ref_input, self.ref_arg_data)
 
         # Given the input data, the resultsdb should be called once, and only
         #   once, calling "create_result".
@@ -228,15 +220,15 @@
         # Select the keyword arguments of that call
         call_data = call[2]
 
-        # the log url depends on the env_data, so construct it here
+        # the log url depends on the arg_data, so construct it here
         ref_log_url = '%s/all/%s/task_output/%s' %\
-                      (self.conf.artifacts_baseurl, self.ref_envdata['uuid'], cd.artifact)
+                      (self.conf.artifacts_baseurl, self.ref_arg_data['uuid'], cd.artifact)
 
         assert call_data['log_url'] == ref_log_url
 
     def test_create_job(self):
         # make sure that the proper API calls are made to create a resultsdb job
-        test_jobdata = self.test_rdb.create_resultsdb_job(self.ref_envdata['checkname'],
+        test_jobdata = self.test_rdb.create_resultsdb_job(self.ref_arg_data['checkname'],
                                                           self.ref_refurl)
 
         assert test_jobdata == self.ref_jobdata
@@ -263,7 +255,7 @@
 
         self.stub_rdb.get_testcase = exception_raiser(ResultsDBapiException('Testcase not found'))
 
-        self.test_rdb.ensure_testcase_exists(self.ref_envdata['checkname'])
+        self.test_rdb.ensure_testcase_exists(self.ref_arg_data['checkname'])
 
         rdb_calls = self.stub_rdb.calls()
 
@@ -275,7 +267,7 @@
         # check to make sure that a testcase is _not_ created in the case that
         # it already exists
 
-        self.test_rdb.ensure_testcase_exists(self.ref_envdata['checkname'])
+        self.test_rdb.ensure_testcase_exists(self.ref_arg_data['checkname'])
 
         rdb_calls = self.stub_rdb.calls()
 
@@ -285,8 +277,8 @@
     def test_ensure_testcase_cached(self):
         # check to make sure that ensure_testcase_exists does not query resultsdb unnecessarily
 
-        self.test_rdb.ensure_testcase_exists(self.ref_envdata['checkname'])
-        self.test_rdb.ensure_testcase_exists(self.ref_envdata['checkname'])
+        self.test_rdb.ensure_testcase_exists(self.ref_arg_data['checkname'])
+        self.test_rdb.ensure_testcase_exists(self.ref_arg_data['checkname'])
 
         rdb_calls = self.stub_rdb.calls()
 
@@ -297,7 +289,7 @@
         """Checks whether YAML is correctly mapped to the reporting method's
         arguments."""
 
-        output = self.test_rdb.process(self.ref_input, self.ref_envdata)
+        output = self.test_rdb.process(self.ref_input, self.ref_arg_data)
         data = check.import_YAML(output)
 
         assert data[0]._internal['resultsdb_result_id'] == 1234
diff --git a/testing/test_taskformula.py b/testing/test_taskformula.py
--- a/testing/test_taskformula.py
+++ b/testing/test_taskformula.py
@@ -33,39 +33,39 @@
 
 class TestTaskYamlMetadata(object):
     def setup_method(self, method):
-        self.taskdata = create_yamldata()
-        self.test_task = taskformula.parse_yaml(yaml.safe_dump(self.taskdata))
+        self.formula = create_yamldata()
+        self.test_task = taskformula.parse_yaml(yaml.safe_dump(self.formula))
 
     def test_taskyaml_taskname(self):
-        assert self.test_task['name'] == self.taskdata['name']
+        assert self.test_task['name'] == self.formula['name']
 
     def test_taskyaml_taskdesc(self):
-        assert self.test_task['desc'] == self.taskdata['desc']
+        assert self.test_task['desc'] == self.formula['desc']
 
     def test_taskyaml_taskmaintainer(self):
-        assert self.test_task['maintainer'] == self.taskdata['maintainer']
+        assert self.test_task['maintainer'] == self.formula['maintainer']
 
     def test_taskyaml_taskdeps(self):
-        assert self.test_task['deps'] == self.taskdata['deps']
+        assert self.test_task['deps'] == self.formula['deps']
 
     def test_taskyaml_taskinput(self):
-        assert self.test_task['input'] == self.taskdata['input']
+        assert self.test_task['input'] == self.formula['input']
 
 
 class TestTaskYamlActionsNoVariables(object):
     def test_taskyaml_simple_action(self):
         ref_action = {'name': 'testaction', 'action': {'key': 'value'}}
-        taskdata = create_yamldata(actions=[ref_action])
+        formula = create_yamldata(actions=[ref_action])
 
-        test_task = taskformula.parse_yaml(yaml.safe_dump(taskdata))
+        test_task = taskformula.parse_yaml(yaml.safe_dump(formula))
 
         assert test_task['actions'][0] == ref_action
 
     def test_taskyaml_multiple_actions(self):
         ref_action = {'name': 'testaction', 'action': {'key': 'value'}}
-        taskdata = create_yamldata(actions=[ref_action, ref_action, ref_action])
+        formula = create_yamldata(actions=[ref_action, ref_action, ref_action])
 
-        test_task = taskformula.parse_yaml(yaml.safe_dump(taskdata))
+        test_task = taskformula.parse_yaml(yaml.safe_dump(formula))
 
         assert len(test_task['actions']) == 3
 

