diff --git a/docs/source/library.rst b/docs/source/library.rst
--- a/docs/source/library.rst
+++ b/docs/source/library.rst
@@ -35,6 +35,12 @@
 .. automodule:: libtaskotron.config_defaults
    :members:
 
+context
+=======
+
+.. automodule:: libtaskotron.context
+   :members:
+
 exceptions
 ==========
 
diff --git a/libtaskotron/check.py b/libtaskotron/check.py
--- a/libtaskotron/check.py
+++ b/libtaskotron/check.py
@@ -7,14 +7,16 @@
 from __future__ import absolute_import
 import pprint
 import collections
+import sys
 
 import tap
+from pytap13 import TAP13
 
-from . import python_utils
-from . import exceptions as exc
-from .logger import log
+import libtaskotron.exceptions as exc
+from libtaskotron import python_utils
+from libtaskotron.logger import log
+from libtaskotron import context
 
-from pytap13 import TAP13
 
 # a list of reserved keywords for TAP output, which can't be overridden in
 # keyvals
@@ -240,9 +242,9 @@
 def export_TAP(*check_details):
     '''Generate TAP output used for reporting to ResultsDB.
 
-    Note: You need to provide all your :class:`CheckDetail`s in a single pass
-    in order to generate a valid TAP output. You can't call this method several
-    times and then simply join the outputs simply as strings.
+    Note: You need to provide all your :class:`CheckDetails <CheckDetail>` in a
+    single pass in order to generate a valid TAP output. You can't call this
+    method several times and then simply join the outputs simply as strings.
 
     :param check_details: any number of :class:`CheckDetail` instances
     :return: TAP output with results for every :class:`CheckDetail` instance
@@ -291,7 +293,8 @@
         if detail.outcome in ['PASSED', 'INFO']:
             tap_outcome = tap.PASS
 
-        name = '$CHECKNAME for '
+        task_name = context.get_context().task_name
+        name = task_name + ' for '
         if detail.report_type:
             name += '%s ' % pretty_type_name.get(detail.report_type,
                                                  detail.report_type)
diff --git a/libtaskotron/context.py b/libtaskotron/context.py
new file mode 100644
--- /dev/null
+++ b/libtaskotron/context.py
@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+# Copyright 2014, Red Hat, Inc.
+# License: GNU General Public License version 2 or later
+
+'''Globally accessible data about the task being executed.'''
+
+from __future__ import absolute_import
+import sys
+
+
+_context = None
+'''A singleton instance of Context'''
+
+
+def get_context():
+    '''Get the Context instance. This method is implemented using the singleton
+    pattern - you will always receive the same instance, which will get
+    auto-initialized on the first method call.
+
+    :return: a global :class:`Context` instance
+    '''
+    global _context
+    if _context is None:
+        _context = Context()
+    return _context
+
+
+class Context(object):
+    '''Access information about task being executed through this class. The data
+    is set up early during :class:`~runner.Runner` initialization and stay
+    constant throughout the task life cycle.
+
+    This class is not initialized with proper data if you don't run the task
+    via taskotron runner (``runtask``).
+    '''
+
+    task_recipe = {}
+    '''(dict) A nested dictionary-like structure parsed from task recipe YAML
+    file. The structure contents exactly matches file contents - no variable
+    expansion is performed.'''
+    task_recipe_file = None
+    '''(str) A relative path to the task recipe YAML file.'''
+    workdir = None
+    '''(str) A temporary directory path which can be used by the task when
+    performing its checks and actions. This directory will also be used by some
+    libtaskotron library functions, e.g. when downloading RPMs from Koji.'''
+    job_id = None
+    '''(str) A job identifier necessary for BuildBot integration.'''
+
+    @property
+    def task_name(self):
+        '''(str) The name of the running task, e.g. ``rpmlint`` or ``depcheck``.
+        It's extracted from the task recipe. If there is no recipe (the task is
+        not run through taskotron runner), ``sys.argv[0]`` is returned as a
+        fallback value.'''
+        return self.task_recipe.get('name', sys.argv[0])
diff --git a/libtaskotron/directives/__init__.py b/libtaskotron/directives/__init__.py
--- a/libtaskotron/directives/__init__.py
+++ b/libtaskotron/directives/__init__.py
@@ -5,6 +5,6 @@
     def __init__(self):
         pass
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         raise NotImplementedError
 
diff --git a/libtaskotron/directives/bodhi_comment_directive.py b/libtaskotron/directives/bodhi_comment_directive.py
--- a/libtaskotron/directives/bodhi_comment_directive.py
+++ b/libtaskotron/directives/bodhi_comment_directive.py
@@ -24,14 +24,13 @@
 directive_class = 'BodhiCommentDirective'
 
 from libtaskotron.directives import BaseDirective
-
 from libtaskotron.logger import log
 from libtaskotron import check
 from libtaskotron import config
 from libtaskotron import bodhi_utils
-
 from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
 from libtaskotron.rpm_utils import basearch
+from libtaskotron import context
 
 import datetime
 import re
@@ -146,8 +145,6 @@
     kojitag -- the koji tag being tested (affects the expected tests)
     '''
 
-    Config = config.get_config()
-
     log.info("checking email needed for %s (%s)", update_name, kojitag)
     # compute current state
     update_state = BodhiUpdateState(update_name, kojitag=kojitag)
@@ -372,16 +369,15 @@
     format: "bodhi_comment:
                 results: <TAP13>
                 doreport: [all, onchange]"
-    Also note, that 'checkname' needs to be present in env_data.
     """
     def __init__(self, bodhi_api=None):
 
         if bodhi_api:
             self.bodhi_api = bodhi_api
         else:
             self.bodhi_api = bodhi_utils.BodhiUtils()
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         output_data = []
 
 
@@ -402,10 +398,6 @@
                     "set to invalid value '%s'. Valid values are: "\
                     "'all', 'onchange'.")
 
-        if 'checkname' not in env_data:
-            raise TaskotronDirectiveError("The bodhi_comment directive "\
-                    "requires checkname.")
-
         try:
             check_details = check.import_TAP(input_data['results'])
         except TaskotronValueError as e:
@@ -419,10 +411,12 @@
 
         # ? Log when no results of the type are found ?
 
+        task_name = context.get_context().task_name
+
         for detail in check_details:
             #TODO: replace url with proper URL
             outcome = _post_testresult(self.bodhi_api, detail.item,
-                        env_data['checkname'],
+                        task_name,
                         detail.outcome,
                         url = "http://example.com",
                         doreport = input_data['doreport'],
@@ -432,7 +426,7 @@
             if not outcome:
                 log.warning("Failed to post Bodhi Comment: `%s` `%s` `%s`",
                             detail.item,
-                            env_data['checkname'],
+                            task_name,
                             detail.outcome)
 
             output_data.append(outcome)
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
@@ -6,9 +6,9 @@
 import libtaskotron.bodhi_utils as bodhi
 from libtaskotron.koji_utils import KojiClient
 from libtaskotron.directives import BaseDirective
-
 from libtaskotron.logger import log
 from libtaskotron.exceptions import TaskotronDirectiveError
+from libtaskotron import context
 
 directive_class = 'BodhiDirective'
 
@@ -59,7 +59,7 @@
 
         return downloaded_rpms
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         output_data = {}
 
         valid_actions = ['download']
@@ -77,7 +77,7 @@
                    " requires both 'bodhi_id' and"
                    " 'arch' arguments. Detected arguments: %s" % detected_args)
 
-            workdir = env_data['workdir']
+            workdir = context.get_context().workdir
             update = input_data['bodhi_id']
             if 'all' in input_data['arch']:
                 arches = ['i386', 'x86_64', 'noarch', 'armhfp']
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
@@ -8,7 +8,7 @@
 
 
 class CreaterepoDirective(BaseDirective):
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         """For the createrepo directive, we're expecting a yaml declaration of
         the form "createrepo: repodir=/path/to/some/dir"
         """
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
@@ -18,7 +18,7 @@
       optional params: msg
     """
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         expected_result = input_data['result']
 
         if expected_result.lower() == 'fail':
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
@@ -5,6 +5,7 @@
 from libtaskotron.directives import BaseDirective
 from libtaskotron.exceptions import TaskotronDirectiveError
 from libtaskotron import rpm_utils
+from libtaskotron import context
 
 directive_class = 'KojiDirective'
 
@@ -33,7 +34,7 @@
         else:
             self.koji = koji_session
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         valid_actions = ['download', 'download_tag']
 
         output_data = {}
@@ -51,7 +52,7 @@
                 "arguments: %s" % detected_args)
 
         if not 'target_dir' in input_data:
-            self.target_dir = env_data['workdir']
+            self.target_dir = context.get_context().workdir
         else:
             self.target_dir = input_data['target_dir']
 
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
@@ -98,7 +98,7 @@
 
         return rc
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         if 'rpmdir' not in input_data or 'arch' not in input_data:
             detected_args = ', '.join(input_data.keys())
             raise TaskotronDirectiveError(
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
@@ -1,9 +1,11 @@
 from __future__ import absolute_import
 import imp
 import os
+import copy
 
 from libtaskotron.directives import BaseDirective
 from libtaskotron.exceptions import TaskotronDirectiveError
+from libtaskotron import context
 
 directive_class = 'PythonDirective'
 
@@ -97,27 +99,27 @@
             raise TaskotronDirectiveError("The file %s does not exist!"
                                           % filename)
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
         """For the python directive, we're expecting a yaml declaration of the
         form
         "python:
             file=<python file> callable=<method name> [kwarg1=something ...]"
 
         @param input_data dictionary of all kwargs from yaml declaration,
             including callable and file
-        @param env_data information on the environment in which we're running
         @return output from the method specified, this is expected to be TAP
             output
         """
+        input_data = copy.deepcopy(input_data)
 
         if 'callable' not in input_data or 'file' not in input_data:
             detected_args = ', '.join(input_data.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['taskfile'])
+        basedir = os.path.dirname(context.get_context().task_recipe_file)
 
         pyfile = os.path.join(basedir, input_data.pop('file'))
 
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
@@ -18,15 +18,15 @@
 #       Josef Skladanka <jskladan@redhat.com>
 
 from __future__ import absolute_import
-from libtaskotron.directives import BaseDirective
 
+import resultsdb_api
+
+from libtaskotron.directives import BaseDirective
 from libtaskotron import check
 from libtaskotron import config
-
 from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
 from libtaskotron.logger import log
-
-import resultsdb_api
+from libtaskotron import context
 
 directive_class = 'ResultsdbDirective'
 
@@ -57,7 +57,7 @@
         """
 
         try:
-            testcase = self.resultsdb.get_testcase(name)
+            _ = self.resultsdb.get_testcase(name)
             return
         except resultsdb_api.ResultsDBapiException, e:
             if e.message != 'Testcase not found':
@@ -120,14 +120,10 @@
 
         return "default", "-1"
 
-    def process(self, input_data, env_data):
+    def process(self, input_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 "\
-                    "resultsdb_job_id and checkname.")
-
         # checking if reporting is enabled is done after importing tap which
         # serves as validation of input results
         try:
@@ -143,23 +139,24 @@
             log.info('\n'.join([str(detail) for detail in check_details]))
             return
 
-        builder, buildid = self.parse_jobid(env_data['jobid'])
+        context_ = context.get_context()
+        builder, buildid = self.parse_jobid(context_.job_id)
 
         # 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 = '%s/builders/%s/builds/%s' % (self.masterurl, builder, buildid)
-        job_data = self.create_resultsdb_job(env_data['checkname'], refurl=job_url)
+        job_data = self.create_resultsdb_job(context_.task_name, refurl=job_url)
 
-        self.ensure_testcase_exists(env_data['checkname'])
+        self.ensure_testcase_exists(context_.task_name)
 
         output = []
 
         for detail in check_details:
             log_url = '%s/steps/%s/logs/stdio' % (job_url, self.task_stepname)
             try:
                 result = self.resultsdb.create_result(
                         job_id = job_data['id'],
-                        testcase_name = env_data['checkname'],
+                        testcase_name = context_.task_name,
                         outcome = detail.outcome,
                         summary = detail.summary or None,
                         log_url = log_url,
@@ -171,7 +168,7 @@
             except resultsdb_api.ResultsDBapiException, e:
                 log.error(e)
                 log.error("Failed to store ResulsDB: `%s` `%s` `%s`",
-                            detail.item, env_data['checkname'], detail.outcome)
+                            detail.item, context_.task_name, detail.outcome)
 
         # move job to completed
         self.complete_resultsdb_job(job_data['id'])
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
@@ -19,10 +19,7 @@
 
 from __future__ import absolute_import
 from libtaskotron.directives import BaseDirective
-
-from libtaskotron import config
 from libtaskotron import yumrepoinfo
-
 from libtaskotron.exceptions import TaskotronDirectiveError
 from libtaskotron.logger import log
 
@@ -47,7 +44,7 @@
     def __init__(self, repoinfo = None):
         self.repoinfo = repoinfo
 
-    def process(self, input_data, env_data):
+    def process(self, input_data):
 
         if 'koji_tag' not in input_data or 'arch' not in input_data:
             raise TaskotronDirectiveError("The yumrepoinfo directive requires "\
diff --git a/libtaskotron/runner.py b/libtaskotron/runner.py
--- a/libtaskotron/runner.py
+++ b/libtaskotron/runner.py
@@ -11,6 +11,7 @@
 from libtaskotron import logger
 from libtaskotron import python_utils
 from libtaskotron import config
+from libtaskotron import context
 from libtaskotron.logger import log
 from libtaskotron.exceptions import TaskotronYamlError
 
@@ -20,21 +21,29 @@
 
 
 class Runner(object):
-    def __init__(self, taskdata, argdata, workdir=None):
+    def __init__(self, taskdata, envdata, workdir=None):
         self.taskdata = taskdata
-        self.envdata = argdata
+        self.envdata = envdata
         self.working_data = {}
         self.directives = {}
         self.workdir = workdir or tempfile.mkdtemp(prefix="task-",
                                       dir=config.get_config().tmpdir)
 
+
     def run(self):
         self._validate_input()
         self.envdata['workdir'] = self.workdir
-        self.envdata['checkname'] = self.taskdata['name']
+
+        # set up the global Context
+        context_ = context.get_context()
+        context_.task_recipe = copy.deepcopy(self.taskdata)
+        context_.task_recipe_file = self.envdata['task_recipe_file']
+        context_.workdir = self.workdir
+        context_.job_id = self.envdata['job_id']
 
         self.do_actions()
 
+
     def _load_directive(self, directive_name, directive_dir=None):
         # look in default path if nothing is specified
         if not directive_dir:
@@ -51,6 +60,7 @@
         loaded_directive = imp.load_source(real_name, directive_file)
         self.directives[directive_name] = loaded_directive
 
+
     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`
@@ -61,22 +71,24 @@
         :return: a rendered action
         :rtype: dict
         '''
-        # copy the input so that we don't disrupt what we're processing
+        # copy the input so that we don't alter the provided object
         rendered_action = copy.deepcopy(action)
 
         variables = copy.deepcopy(self.envdata)
         variables.update(self.working_data)
         taskyaml.replace_vars_in_action(rendered_action, variables)
 
         return rendered_action
 
+
     def _extract_directive_from_action(self, action):
         for key in action:
             if key not in ['name', 'export']:
                 return key
         raise TaskotronYamlError('no directive found in action %s' %
                                  str(action))
 
+
     def do_single_action(self, action):
         '''Execute a single action from the task. See :meth:`do_actions` to see
         how an action looks like.
@@ -95,12 +107,12 @@
 
         directive_callable = getattr(directive_object, directive_classname)()
 
-        output = directive_callable.process(rendered_action[directive_name],
-                                            self.envdata)
+        output = directive_callable.process(rendered_action[directive_name])
 
         if 'export' in action:
             self.working_data[action['export']] = output
 
+
     def do_actions(self):
         '''Sequentially run all actions for a task. An 'action' is a single step
         under the ``task:`` key. An example action looks like::
@@ -118,6 +130,7 @@
         for action in self.taskdata['task']:
             self.do_single_action(action)
 
+
     def _validate_input(self):
         if 'input' not in self.taskdata:
             return
@@ -138,6 +151,7 @@
                 raise TaskotronYamlError("Required input arg '%s' "
                                          "was not defined" % arg)
 
+
     def _validate_env(self):
         # TODO: implement this
         raise NotImplementedError("Environment validation is not"
@@ -156,7 +170,7 @@
     parser.add_argument("-t", "--type",
                         choices=_ITEM_TYPES,
                         help="type of --item argument")
-    parser.add_argument("-j", "--jobid", default="-1",
+    parser.add_argument("-j", "--jobid", default="-1", dest='job_id',
                         help="optional job identifier used to render log urls")
     return parser
 
@@ -187,15 +201,16 @@
 
     logger.init(level=logging.DEBUG)
 
-    arg_data = process_args(vars(args))
-    arg_data['taskfile'] = args.task[0]
+    envdata = process_args(vars(args))
+    envdata['task_recipe_file'] = args.task[0]
 
-    task_data = taskyaml.parse_yaml_from_file(arg_data['taskfile'])
+    taskdata = taskyaml.parse_yaml_from_file(envdata['task_recipe_file'])
 
-    if not task_data:
-        raise TaskotronYamlError('Input file should not be empty')
+    if not taskdata:
+        raise TaskotronYamlError('Input file should not be empty: %s' %
+                                 envdata['task_recipe_file'])
 
-    task_runner = Runner(task_data, arg_data)
+    task_runner = Runner(taskdata, envdata)
     task_runner.run()
 
     log.info('Check execution finished. Showing stored variables:')
diff --git a/testing/functest_python_directive.py b/testing/functest_python_directive.py
--- a/testing/functest_python_directive.py
+++ b/testing/functest_python_directive.py
@@ -1,37 +1,42 @@
 import os
-import copy
-from libtaskotron.directives import python_directive
+import pytest
 
+from libtaskotron.directives import python_directive
+from libtaskotron import context
 
+@pytest.mark.usefixtures('setup')
 class TestTaskMethod(object):
-    def setup_method(self, method):
+
+    @pytest.fixture
+    def setup(self, monkeypatch):
+        '''Run this before every test invocation'''
         self.ref_taskyaml = 'footask.yml'
         self.ref_pyfile = 'some_loadable_test.py'
-        self.ref_env = {'taskfile': os.path.join(os.path.dirname(
-            os.path.abspath(__file__)), self.ref_taskyaml)}
         self.test_directive = python_directive.PythonDirective()
 
+        stub_context = context.Context()
+        stub_context.task_recipe_file = os.path.join(os.path.dirname(
+            os.path.abspath(__file__)), self.ref_taskyaml)
+        monkeypatch.setattr(context, '_context', stub_context)
+
     def testfunc_task_method(self):
         ref_input = {'file': self.ref_pyfile, 'callable': 'task_method'}
 
-        test_output = self.test_directive.process(copy.copy(ref_input),
-                                                  self.ref_env)
+        test_output = self.test_directive.process(ref_input)
 
         assert test_output == "I'm a task method!"
 
     def testfunc_class_embedded_call(self):
         ref_input = {'file': self.ref_pyfile,
                      'callable': 'embedded_task_target'}
 
-        test_output = self.test_directive.process(copy.copy(ref_input),
-                                                  self.ref_env)
+        test_output = self.test_directive.process(ref_input)
 
         assert test_output == "I'm a __call__ method in a class!"
 
     def testfunc_class_target(self):
         ref_input = {'file': self.ref_pyfile, 'callable': 'task_class_target'}
 
-        test_output = self.test_directive.process(copy.copy(ref_input),
-                                                  self.ref_env)
+        test_output = self.test_directive.process(ref_input)
 
         assert test_output == "I'm a task class method!"
diff --git a/testing/test_bodhi_comment_directive.py b/testing/test_bodhi_comment_directive.py
--- a/testing/test_bodhi_comment_directive.py
+++ b/testing/test_bodhi_comment_directive.py
@@ -8,9 +8,9 @@
 
 from libtaskotron.directives import bodhi_comment_directive
 from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
-
 from libtaskotron import check
 from libtaskotron import config
+from libtaskotron import context
 
 
 @pytest.mark.usefixtures('setup')
@@ -53,9 +53,10 @@
                 'results': tap,
                 'doreport': 'onchange',
                 }
-        self.ref_envdata = {
-                'checkname': 'depcheck',
-                }
+
+        stub_context = context.Context()
+        stub_context.task_recipe = {'name': 'depcheck'}
+        monkeypatch.setattr(context, '_context', stub_context)
 
     def test_config_reporting_disabled(self):
         """Checks config options can disable reporting."""
@@ -65,34 +66,26 @@
            Config.reporting_enabled = r_e
            Config.report_to_bodhi = r_t_b
 
-           assert self.directive.process(self.ref_input, self.ref_envdata) is None
+           assert self.directive.process(self.ref_input) is None
 
     def test_missing_arguments_in_inputdata(self):
         """Check if arguments raise exception"""
         with pytest.raises(TaskotronDirectiveError):
             input_data = deepcopy(self.ref_input)
             del(input_data['results'])
-            self.directive.process(input_data, self.ref_envdata)
+            self.directive.process(input_data)
 
         with pytest.raises(TaskotronDirectiveError):
             input_data = deepcopy(self.ref_input)
             del(input_data['doreport'])
-            self.directive.process(input_data, self.ref_envdata)
+            self.directive.process(input_data)
 
     def test_wrong_doreport_value(self):
         """Checks whether unsupported doreport value"""
         with pytest.raises(TaskotronDirectiveError):
             input_data = deepcopy(self.ref_input)
             input_data['doreport']  = 'FooBar'
-            self.directive.process(input_data, self.ref_envdata)
-
-    def test_missing_checkname(self, monkeypatch):
-        """Checks if missing checkname raises exception"""
-        with pytest.raises(TaskotronDirectiveError):
-            envdata = deepcopy(self.ref_envdata)
-            del(envdata['checkname'])
-
-            self.directive.process(self.ref_input, envdata)
+            self.directive.process(input_data)
 
     def test_failed_tap_import(self, monkeypatch):
         """Checks if failed TAP import raises exception"""
@@ -102,7 +95,7 @@
         monkeypatch.setattr(check, 'import_TAP', mock_raise)
 
         with pytest.raises(TaskotronDirectiveError):
-            self.directive.process(self.ref_input, self.ref_envdata)
+            self.directive.process(self.ref_input)
 
 
     def test_parse_result_from_comment(self):
@@ -261,7 +254,7 @@
         the bodhi comment call."""
         self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
 
-        self.directive.process(self.ref_input, self.ref_envdata)
+        self.directive.process(self.ref_input)
 
         # Select the first call of "comment" method.
         call = [call for call in self.stub_bodhi.client.calls() if call[0] == 'comment'][0]
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
@@ -9,10 +9,13 @@
 
 from libtaskotron.directives import bodhi_directive
 from libtaskotron.exceptions import TaskotronDirectiveError
+from libtaskotron import context
 
+@pytest.mark.usefixtures('setup')
 class TestBodhiDownloads():
 
-    def setup_method(self, method):
+    @pytest.fixture
+    def setup(self, monkeypatch):
         '''Run this before every test invocation'''
         self.ref_arch = ['x86_64']
         self.ref_bodhi_id = 'FEDORA-1234-56789'
@@ -30,20 +33,23 @@
                           'arch': self.ref_arch,
                           'bodhi_id': self.ref_bodhi_id
                          }
-        self.ref_envdata = {'workdir': self.ref_workdir}
         self.ref_rpmfile = '%s/%s.rpm' % (self.ref_workdir, self.ref_nvr1)
 
         self.helper = bodhi_directive.BodhiDirective()
 
+        stub_context = context.Context()
+        stub_context.workdir = self.ref_workdir
+        monkeypatch.setattr(context, '_context', stub_context)
+
 
     def test_action_download_existing_update(self):
         '''Test download of existing update'''
         stub_bodhi = Dingus(query_update__returns = self.ref_update)
         stub_koji = Dingus(get_nvr_rpms__returns = [self.ref_rpmfile])
 
         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)
 
         ref_output_data = {'downloaded_rpms': [self.ref_rpmfile,
                                                self.ref_rpmfile]}
@@ -70,7 +76,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)
 
         ref_arches = set(['i386', 'x86_64', 'noarch', 'armhfp'])
         getrpms_calls = stub_koji.calls()
@@ -92,7 +98,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)
 
         getrpms_calls = stub_koji.calls()
         req_arches = map(lambda x: x[1][2], getrpms_calls)
@@ -113,7 +119,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)
 
         getrpms_calls = stub_koji.calls()
         req_arches = map(lambda x: x[1][2], getrpms_calls)
@@ -134,7 +140,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)
 
         getrpms_calls = stub_koji.calls()
         req_arches = map(lambda x: x[1][2], getrpms_calls)
@@ -152,7 +158,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)
 
 
     def test_invalid_action(self):
@@ -167,7 +173,7 @@
 
         # 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)
 
 
     def test_action_download_insufficient_input_data(self):
@@ -181,16 +187,16 @@
 
         # Tests with no information
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(ref_input, self.ref_envdata)
+            test_bodhi.process(ref_input)
 
         ref_input['arch'] = self.ref_arch
 
         # Tests with only arch, or bodhi_id given
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(ref_input, self.ref_envdata)
+            test_bodhi.process(ref_input)
 
         ref_input.pop('arch')
         ref_input['bodhi_id'] = self.ref_bodhi_id
 
         with pytest.raises(TaskotronDirectiveError):
-            test_bodhi.process(ref_input, self.ref_envdata)
+            test_bodhi.process(ref_input)
diff --git a/testing/test_context.py b/testing/test_context.py
new file mode 100644
--- /dev/null
+++ b/testing/test_context.py
@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# Copyright 2014, Red Hat, Inc.
+# License: GNU General Public License version 2 or later
+
+'''Unit tests for libtaskotron/context.py'''
+
+import sys
+import pytest
+
+from libtaskotron import context
+
+
+@pytest.mark.usefixtures('setup')
+class TestContext(object):
+
+    @pytest.fixture
+    def setup(self, monkeypatch):
+        '''Run this before every test invocation'''
+        monkeypatch.setattr(context, '_context', None)
+
+    def test_singleton_instance(self):
+        '''Test whether we really have a singleton Context instance'''
+        context_ = context.get_context()
+        assert isinstance(context_, context.Context)
+        assert context_ is context._context
+        context2 = context.get_context()
+        assert context2 is context_
+
+    def test_task_name_from_recipe(self):
+        '''Task name should be taken from task recipe'''
+        context_ = context.get_context()
+        context_.task_recipe = {'name': 'testscript'}
+        assert context_.task_name == 'testscript'
+
+    def test_task_name_from_argv(self, monkeypatch):
+        '''Task name should be taken from argv when recipe is empty'''
+        context_ = context.get_context()
+        monkeypatch.setattr(sys, 'argv', ['somerecipename', 'somearg'])
+        assert context_.task_name == 'somerecipename'
diff --git a/testing/test_directives/test_directive.py b/testing/test_directives/test_directive.py
--- a/testing/test_directives/test_directive.py
+++ b/testing/test_directives/test_directive.py
@@ -1,5 +1,5 @@
 from libtaskotron.directives import BaseDirective
 
 class TestDirective(BaseDirective):
-    def process(self, command, input_data, env_data):
+    def process(self, command, input_data):
         return "this is just a test"
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
@@ -1,40 +1,43 @@
+import pytest
 from dingus import Dingus
 
 from libtaskotron.directives import koji_directive
+from libtaskotron import context
 
+@pytest.mark.usefixtures('setup')
 class TestKojiDirective():
-    def setup_method(self, method):
+
+    @pytest.fixture
+    def setup(self, monkeypatch):
+        '''Run this before every test invocation'''
         self.ref_nvr = 'foo-1.2-3.fc99'
         self.ref_arch = ['noarch']
         self.ref_tag = 'tagfoo'
         self.ref_name = 'foo'
         self.ref_version = '1.2'
         self.ref_release = '3.fc99'
         self.ref_buildid = 123456
-
         self.ref_build = {'package_name': self.ref_name,
                           'version': self.ref_version,
                           'release': self.ref_release,
                           'id': self.ref_buildid}
-
         self.ref_rpms = [{'name': self.ref_name, 'version': self.ref_version,
                           'release': self.ref_release, 'nvr': self.ref_nvr,
                           'arch': self.ref_arch},
                     {'name': self.ref_name, 'version': self.ref_version,
                      'release': self.ref_release, 'nvr': self.ref_nvr,
                      'arch': ['src']}]
-
         self.ref_tagged = [{'nvr': self.ref_nvr}]
-
         self.ref_url = 'http://downloads.example.com/builds/%s.noarch.rpm'\
                        % self.ref_nvr
         self.helper = koji_directive.KojiDirective()
-
-        self.ref_envdata = {'workdir': '/var/tmp/foo'}
-
         self.ref_rpms = ['/var/tmp/fake/%s.%s.rpm'
                          % (self.ref_nvr, self.ref_arch)]
 
+        stub_context = context.Context()
+        stub_context.workdir = '/var/tmp/foo'
+        monkeypatch.setattr(context, '_context', stub_context)
+
     def test_parse_download_command(self):
 
         self.ref_input = {'action': 'download',
@@ -45,7 +48,7 @@
 
         test_helper = koji_directive.KojiDirective(stub_koji)
 
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input)
 
         getrpm_calls = stub_koji.calls()
         requested_nvr = getrpm_calls[0][1][0]
@@ -63,7 +66,7 @@
 
         test_helper = koji_directive.KojiDirective(stub_koji)
 
-        test_helper.process(self.ref_input, self.ref_envdata)
+        test_helper.process(self.ref_input)
 
         getrpm_calls = stub_koji.calls()
         requested_tag = getrpm_calls[0][1][0]
@@ -81,7 +84,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)
 
         assert test_helper.arches == self.ref_arch
 
@@ -93,18 +96,17 @@
         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)
 
         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'}
 
         stub_koji = Dingus()
         test_helper = koji_directive.KojiDirective(stub_koji)
-        test_helper.process(ref_input, ref_envdata)
+        test_helper.process(ref_input)
 
         getrpm_calls = stub_koji.calls()
         print getrpm_calls
@@ -117,11 +119,10 @@
     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'}
 
         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)
 
         getrpm_calls = stub_koji.calls()
         requested_arches = getrpm_calls[0][1][2]
diff --git a/testing/test_python_directive.py b/testing/test_python_directive.py
--- a/testing/test_python_directive.py
+++ b/testing/test_python_directive.py
@@ -1,11 +1,14 @@
-from libtaskotron.directives import python_directive
-from libtaskotron.exceptions import TaskotronDirectiveError
-from dingus import Dingus
 import os
 import imp
-import pytest
 import copy
 
+import pytest
+from dingus import Dingus
+
+from libtaskotron.directives import python_directive
+from libtaskotron.exceptions import TaskotronDirectiveError
+from libtaskotron import context
+
 
 class TestCheckfile(object):
     def test_existing_file(self, monkeypatch):
@@ -157,13 +160,14 @@
             test_directive.execute(ref_modulename, ref_methodname, ref_kwargs)
 
 
+@pytest.mark.usefixtures('setup')
 class TestProcess(object):
 
-    def setup_method(self, method):
-
+    @pytest.fixture
+    def setup(self, monkeypatch):
+        '''Run this before every test invocation'''
         self.ref_taskyaml = '/path/to/foo/footask.yml'
         self.ref_input = {'file': 'foo.py', 'callable': 'bar', 'kwarg1': 'baz'}
-        self.ref_env = {'taskfile': self.ref_taskyaml}
         self.ref_pyfile = os.path.join(os.path.dirname(self.ref_taskyaml),
                                        self.ref_input['file'])
 
@@ -173,6 +177,10 @@
                                                         self.stub_imported))
         self.stub_execute = Dingus('execute')
 
+        stub_context = context.Context()
+        stub_context.task_recipe_file = self.ref_taskyaml
+        monkeypatch.setattr(context, '_context', stub_context)
+
     def test_process_checks_file(self, monkeypatch):
 
 
@@ -182,8 +190,7 @@
                             self.stub_pyload.dostuff)
         monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
 
-        test_directive.process(copy.copy(self.ref_input),
-                                             self.ref_env)
+        test_directive.process(self.ref_input)
 
         checkfile_call = self.stub_checkfile.calls[0]
 
@@ -198,8 +205,7 @@
                             self.stub_pyload.dostuff)
         monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
 
-        test_directive.process(copy.copy(self.ref_input),
-                                             self.ref_env)
+        test_directive.process(self.ref_input)
 
         pyload_call = self.stub_pyload.calls[0]
 
@@ -216,10 +222,9 @@
                             self.stub_pyload.dostuff)
         monkeypatch.setattr(test_directive, 'execute', self.stub_execute)
 
-        test_directive.process(copy.copy(self.ref_input),
-                                             self.ref_env)
+        test_directive.process(self.ref_input)
 
         execute_call = self.stub_execute.calls[0]
 
         assert (execute_call.name, execute_call.args, execute_call.kwargs) == (
          '()', (self.stub_imported, self.ref_input['callable'], ref_kwargs), {})
\ No newline at end of file
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
@@ -1,14 +1,13 @@
 """Unit tests for libtaskotron/directives/resultsdb_directive.py"""
 
 import pytest
-from copy import deepcopy
 from dingus import Dingus, exception_raiser
 
 from libtaskotron.directives import resultsdb_directive
 from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
-
 from libtaskotron import check
 from libtaskotron import config
+from libtaskotron import context
 
 from resultsdb_api import ResultsDBapiException
 
@@ -20,31 +19,28 @@
     def setup(self, monkeypatch):
         '''Run this before every test invocation'''
 
+        self.stub_context = context.Context()
+        self.stub_context.task_recipe = {'name': 'test_resultsdb_report'}
+        self.stub_context.job_id = 'all/123'
+        monkeypatch.setattr(context, '_context', self.stub_context)
+
         self.cd = check.CheckDetail(
                     item = 'foo_bar',
                     report_type = check.ReportType.KOJI_BUILD,
                     outcome = 'NEEDS_INSPECTION',
                     summary = 'foo_bar summary',
                     output = ["foo\nbar"],
                     keyvals = {"foo": "moo1", "bar": "moo2"},
                 )
-
-
         tap = check.export_TAP(self.cd)
 
         self.ref_input = {'results': tap}
-        self.ref_envdata = {
-                'resultsdb_job_id': 1,
-                'checkname': 'test_resultsdb_report',
-                'jobid': 'all/123',
-                }
-
         self.ref_jobid = 1234
-        self.ref_refurl = u'http://example.com/%s' % self.ref_envdata['checkname']
+        self.ref_refurl = u'http://example.com/%s' % self.stub_context.task_name
         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'name': self.stub_context.task_name,
                         u'ref_url': self.ref_refurl,
                         u'results': [],
                         u'results_count': 0,
@@ -61,40 +57,31 @@
         self.conf.reporting_enabled = True
         self.conf.report_to_resultsdb = True
 
-
     def test_config_reporting_disabled(self):
         """Checks config options can disable reporting."""
         conf = config.get_config()
 
         for r_e, r_t_r in ((False, False), (False, True), (True, False)):
            conf.reporting_enabled = r_e
            conf.report_to_resultsdb = r_t_r
 
-           assert self.test_rdb.process(self.ref_input, self.ref_envdata) is None
+           assert self.test_rdb.process(self.ref_input) is None
 
         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_tap_import(self, monkeypatch):
         """Checks if failed TAP import raises exception"""
         monkeypatch.setattr(check, 'import_TAP',
                             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)
 
     def test_report(self):
         """Checks whether TAP 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)
 
         # Given the input data, the resultsdb should be called once, and only
         #   once, calling "create_result".
@@ -115,13 +102,13 @@
         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('/')
+        ref_builder, ref_jobid = self.stub_context.job_id.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.stub_context.task_name
         assert call_data['outcome'] == self.cd.outcome
         assert call_data['summary'] == self.cd.summary
         assert call_data['log_url'] == ref_log_url
@@ -135,7 +122,7 @@
 
     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.stub_context.task_name,
                                                           self.ref_refurl)
 
         assert test_jobdata == self.ref_jobdata
@@ -162,7 +149,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.stub_context.task_name)
 
         rdb_calls = self.stub_rdb.calls()
 
@@ -174,7 +161,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.stub_context.task_name)
 
         rdb_calls = self.stub_rdb.calls()
 
diff --git a/testing/test_runner.py b/testing/test_runner.py
--- a/testing/test_runner.py
+++ b/testing/test_runner.py
@@ -4,6 +4,7 @@
 import copy
 
 from libtaskotron import runner
+from libtaskotron import context
 from libtaskotron.exceptions import TaskotronYamlError
 
 
@@ -97,6 +98,7 @@
         with pytest.raises(TaskotronYamlError):
             test_runner._validate_input()
 
+
 class TestRunnerSetup():
     def test_trivial_creation(self, tmpdir):
         ref_taskdata = {'preparation': {'koji': 'download nvr'},
@@ -110,6 +112,7 @@
 
         assert test_runner.taskdata == ref_taskdata
 
+
 class TestRunnerPrep():
     def test_prep_invalid_commands(self, tmpdir):
         ref_taskdata = {'preparation': {'turboencabulator':
@@ -121,6 +124,7 @@
         with pytest.raises(Exception):
             test_runner.do_prep()
 
+
 class TestRunnerDirectiveLoader():
 
     def setup_method(self, method):
@@ -154,6 +158,7 @@
         with pytest.raises(Exception):
             test_runner._load_directive(self.ref_directivename, self.ref_dir)
 
+
 class TestRunnerSingleAction():
 
     def setup_method(self, method):
@@ -406,3 +411,24 @@
         test_args = runner.process_args(ref_input)
         assert test_args == ref_args
 
+
+class TestRunnerRun(object):
+
+    def test_run_context_available(self, monkeypatch):
+        '''Make sure that Context is properly initialized on Runner.run()'''
+        monkeypatch.setattr(context, '_context', None)
+        monkeypatch.setattr(runner.Runner, 'do_actions', lambda slf: None)
+
+        taskdata = {'task': []}
+        envdata = {'task_recipe_file': 'somefile',
+                   'job_id': 'foo/123'}
+        test_runner = runner.Runner(taskdata, envdata)
+        test_runner.run()
+
+        context_ = context.get_context()
+        assert isinstance(context_, context.Context)
+        assert context_.task_recipe == taskdata
+        assert context_.task_recipe_file == envdata['task_recipe_file']
+        assert context_.job_id == envdata['job_id']
+        assert context_.workdir is not None
+
diff --git a/testing/test_yumrepoinfo_directive.py b/testing/test_yumrepoinfo_directive.py
--- a/testing/test_yumrepoinfo_directive.py
+++ b/testing/test_yumrepoinfo_directive.py
@@ -57,44 +57,44 @@
         ref_input = {"arch":"x86_64"}
 
         with pytest.raises(TaskotronDirectiveError):
-            directive.process(ref_input, None)
+            directive.process(ref_input)
 
     def test_missing_arch(self):
         directive = yumrepoinfo_directive.YumrepoinfoDirective(self.repoinfo)
         ref_input = {"koji_tag":"rawhide"}
 
         with pytest.raises(TaskotronDirectiveError):
-            directive.process(ref_input, None)
+            directive.process(ref_input)
 
     def test_pending(self):
         directive = yumrepoinfo_directive.YumrepoinfoDirective(self.repoinfo)
         ref_input = {"koji_tag": "f20-pending", "arch": "x86_64"}
 
-        output = directive.process(ref_input, None)
+        output = directive.process(ref_input)
 
         assert output == {"f20": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os"}
 
     def test_rawhide(self):
         directive = yumrepoinfo_directive.YumrepoinfoDirective(self.repoinfo)
         ref_input = {"koji_tag": "rawhide", "arch": "x86_64"}
 
-        output = directive.process(ref_input, None)
+        output = directive.process(ref_input)
 
         assert output == {"rawhide": "http://download.fedoraproject.org/pub/fedora/linux/development/rawhide/x86_64/os"}
 
     def test_bad_kojitag(self):
         directive = yumrepoinfo_directive.YumrepoinfoDirective(self.repoinfo)
         ref_input = {"koji_tag": "my random tag"}
 
         with pytest.raises(TaskotronDirectiveError):
-            directive.process(ref_input, None)
+            directive.process(ref_input)
 
     def test_repo_path(self):
 
         directive = yumrepoinfo_directive.YumrepoinfoDirective(self.repoinfo)
         ref_input = {"koji_tag": "f20-updates", "arch": "x86_64"}
 
-        output = directive.process(ref_input, None)
+        output = directive.process(ref_input)
 
         assert output == {
                 "f20": "http://download.fedoraproject.org/pub/fedora/linux/releases/20/Everything/x86_64/os",
@@ -114,7 +114,7 @@
         directive = yumrepoinfo_directive.YumrepoinfoDirective()
         ref_input = {"koji_tag": "f20-updates", "arch": ref_arch}
 
-        directive.process(ref_input, None)
+        directive.process(ref_input)
 
         # check the first arg of the first call to the stub object
         assert stub_getrepoinfo.calls()[0][1][0] == ref_arch

