diff --git a/conf/taskotron.yaml.example b/conf/taskotron.yaml.example
--- a/conf/taskotron.yaml.example
+++ b/conf/taskotron.yaml.example
@@ -47,19 +47,8 @@
 ## This section controls which result reports you want to send after the test
 ## execution is complete.
 
-## Overall setting whether to send any reports at all. If this is False, no
-## reports will be sent anywhere, regardless of your configuration for
-## individual recipient systems.
+## Whether to send test results to the configured ResultsDB server.
 ## [default: True for production, False for development]
-#reporting_enabled: True
-
-## If True, test results (for selected tests) will be sent as comments to
-## Fedora Update System (Bodhi). This requires that you have Bodhi
-## credentials filled in secrets.conf. See also 'reporting_enabled' option.
-#report_to_bodhi: True
-
-## Whether to send test results to the configured ResultsDB server. See also
-## 'reporting_enabled' option.
 #report_to_resultsdb: True
 
 
@@ -108,16 +97,6 @@
 #download_cache_enabled: False
 
 
-## ==== BODHI EMAIL section ====
-## These configuration options affect how Taskotron decideds to send emails
-## through Bodhi in specific situations.
-
-## How long (in minutes) should we wait before allowing consequent test to
-## re-post a 'FAILED' comment into Bodhi once again.
-## By default 3 days (3*24*60 = 4320).
-#bodhi_posting_comments_span: 4320
-
-
 ## ==== PATHS section ====
 ## Location of various pieces of the project.
 
@@ -167,11 +146,6 @@
 ## All login credentials and other secrets are here. If you add some secret
 ## here, make sure you make this file readable just for the right user accounts.
 
-## FAS (Fedora Accounts System) credentials
-## These credentials are used when reporting results into Bodhi.
-#fas_username: taskotron
-#fas_password: ''
-
 ## SSH private key location. Used for remote task execution, when connecting to
 ## VMs and remote machines. If your systems are not configured for automatic
 ## connection (private keys located in SSH's standard search path), specify a
diff --git a/libtaskotron/config_defaults.py b/libtaskotron/config_defaults.py
--- a/libtaskotron/config_defaults.py
+++ b/libtaskotron/config_defaults.py
@@ -56,9 +56,7 @@
 
     runtask_mode = RuntaskModeName.LOCAL                                    #:
 
-    reporting_enabled = False                                               #:
-    report_to_bodhi = True                                                  #:
-    report_to_resultsdb = True                                              #:
+    report_to_resultsdb = False                                             #:
 
     buildbot_task_step = 'runtask'                                          #:
 
@@ -72,9 +70,6 @@
     artifacts_baseurl = 'http://localhost/artifacts'                        #:
     download_cache_enabled = True                                           #:
 
-    bodhi_posting_comments_span = 4320                                      #:
-                                  # 3 days (3*24*60 = 4320)
-
     tmpdir = '/var/tmp/taskotron'                                           #:
     logdir = '/var/log/taskotron'                                           #:
     client_taskdir = '/var/tmp/taskotron/taskdir'                           #:
@@ -94,8 +89,6 @@
 
     log_file_enabled = False                                                #:
 
-    fas_username = 'taskotron'                                              #:
-    fas_password = ''                                                       #:
     ssh_privkey = ''                                                        #:
 
     def __str__(self):
@@ -112,7 +105,7 @@
 
     runtask_mode = RuntaskModeName.LIBVIRT                                  #:
 
-    reporting_enabled = True                                                #:
+    report_to_resultsdb = True                                              #:
 
     download_cache_enabled = False                                          #:
 
diff --git a/libtaskotron/directives/bodhi_comment_directive.py b/libtaskotron/directives/bodhi_comment_directive.py
deleted file mode 100644
--- a/libtaskotron/directives/bodhi_comment_directive.py
+++ /dev/null
@@ -1,517 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2009-2014, Red Hat, Inc.
-# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
-# See the LICENSE file for more details on Licensing
-from __future__ import absolute_import
-
-DOCUMENTATION = """
-module: bodhi_comment_directive
-short_description: create a comment for a Bodhi update
-description: |
-  Take YAML formmated check results, find all `Bodhi`_ update results in it,
-  and post a comment under each of these updates stating the result of the
-  check.
-
-  .. _Bodhi: https://bodhi.fedoraproject.org
-
-  The comment will roughly look like this::
-
-    Taskotron: depcheck test PASSED on x86_64. Result log: <url>
-
-  .. note:: You have to have ``fas_username`` and ``fas_password`` configured
-    in your config file, otherwise the comments won't be posted.
-
-  .. note:: The <url> will point to the Buildbot's full stdio log.
-    It is possible to make the <url> point to the respective ResultsDB's
-    result page, if you use the ``resultsdb_directive``'s exported output
-    as an input for this directive (see Examples section).
-parameters:
-  results:
-    required: true
-    description: |
-      single or multiple check results in YAML format. Only results
-      with ``type: bodhi_update`` will be processed. The ``item:`` value has
-      to be a Bodhi update ID.
-    type: str
-  doreport:
-    required: true
-    description: |
-      select ``all`` to always post the check result, regardless of
-      previoust Taskotron comments for the same update. Select ``onchange`` to
-      only post comments if the check result status changed (e.g. from ``FAILED``
-      to ``PASSED``), or if the ``FAILED`` status repeats itself **and** long
-      enough time has passed between these two failures (configurable as
-      ``bodhi_posting_comments_span`` in the config file).
-
-      For production purposes you usually want to use ``onchange``, for
-      development purposes you might want to use ``all``.
-    type: str
-    choice: [all, onchange]
-returns: |
-  A list of bool values. The number and order of the bool values matches the
-  number and order of Bodhi update check results in ``results``. The bool value
-  is ``True`` if comment was posted successfully or comment wasn't meant to be
-  posted (either posting is turned off or comment was already posted), ``False``
-  if some problem was encountered.
-raises: |
-  * :class:`.TaskotronDirectiveError`: if ``results`` is not a string in valid
-    YAML format
-  * :class:`.TaskotronValueError`: if ``results`` refer to a Bodhi update which
-    can't be found in Bodhi
-version_added: 0.4
-"""
-
-EXAMPLES = """
-Run ``upgradepath`` check and then report all results to Bodhi (using
-``onchange`` approach)::
-
-    - name: run upgradepath
-      python:
-          file: upgradepath.py
-          callable: main
-          custom_args: [--debug, "${koji_tag}"]
-      export: upgradepath_output
-
-    - name: report results to Bodhi
-      bodhi_comment:
-          results: ${upgradepath_output}
-          doreport: 'onchange'
-
-Run ``upgradepath`` check, report results to ResultsDB and then to
-Bodhi (using ``onchange`` approach). This also causes the url of the
-logs in the Bodhi comment to point to the ResultsDB's respective
-result page, instead of the full stdio log.::
-
-    - name: run upgradepath
-      python:
-          file: upgradepath.py
-          callable: main
-          custom_args: [--debug, "${koji_tag}"]
-      export: upgradepath_output
-
-    - name: report results to ResultsDB
-      resultsdb:
-         results: ${upgradepath_output}
-      export: ${resultsdb_output}
-
-    - name: report results to Bodhi
-      bodhi_comment:
-          results: ${resultsdb_output}
-          doreport: 'onchange'
-"""
-
-from libtaskotron.directives import BaseDirective
-
-from libtaskotron.logger import log
-from libtaskotron import check
-from libtaskotron import config
-from libtaskotron import buildbot_utils
-
-from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
-from libtaskotron.arch_utils import basearch
-
-from libtaskotron.ext.fedora import bodhi_utils
-
-import datetime
-import re
-
-RE_COMMENT = re.compile(r'Taskotron: (?P<test_name>\w+) test (?P<result>\w+)'\
-                              r' on (?P<arch>\w+)\. Result log:[\t \n]+'\
-                              r'(?P<result_url>[/:\w]+).*')
-
-
-# symbols used for consistant declaration of state
-PASS = 'state_PASS'# <%s>' % __name__
-FAIL = 'state_FAIL'# <%s>'% __name__
-INCOMPLETE = 'state_INCOMPLETE'# <%s>' % __name__
-UNKNOWN = 'state_UNKNOWN'# <%s>' % __name__
-
-directive_class = 'BodhiCommentDirective'
-
-class BodhiCommentDirective(BaseDirective):
-
-    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):
-        output_data = []
-
-        Config = config.get_config()
-        if not (Config.reporting_enabled and Config.report_to_bodhi):
-            log.info("Reporting to Bodhi is disabled, not doing anything.")
-            return
-
-        if not ('doreport' in input_data and 'results' in input_data):
-            detected_args = ', '.join(input_data.keys())
-            raise TaskotronDirectiveError("The bodhi_comment directive "\
-                    "requires 'doreport' and 'results' arguments. "\
-                    "Detected arguments: %s" % detected_args)
-
-        if input_data['doreport'] not in ['all', 'onchange']:
-            raise TaskotronDirectiveError("The argument 'doreport' is"\
-                    "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_YAML(input_data['results'])
-        except TaskotronValueError as e:
-            log.exception(e)
-            raise TaskotronDirectiveError("Failed to load the 'results':"\
-                    "%s" % e)
-
-        # Filter the results of "BODHI_UPDATE" type
-        check_details = [r for r in check_details
-                if r.report_type == check.ReportType.BODHI_UPDATE]
-
-        _, log_url = buildbot_utils.get_urls(env_data['jobid'],
-                                             Config.taskotron_master,
-                                             Config.buildbot_task_step)
-
-        log.info('Posting %s results to Bodhi...', len(check_details))
-
-        for index, detail in enumerate(check_details, start=1):
-            # Check for the presence of resultsdb's result id, and create
-            # alternate log_url, than points to the respective frontend page.
-            resultsdb_id = detail._internal.get('resultsdb_result_id', None)
-            if resultsdb_id:
-                log_url = "%s/results/%s" % (Config.resultsdb_frontend, resultsdb_id)
-
-            outcome = _post_testresult(self.bodhi_api, detail.item,
-                        env_data['checkname'],
-                        detail.outcome,
-                        url = log_url,
-                        doreport = input_data['doreport'],
-                        arch = detail.keyvals.get('arch', 'noarch'),
-                        )
-
-            if not outcome:
-                log.warning("Failed to post Bodhi Comment: `%s` `%s` `%s`",
-                            detail.item,
-                            env_data['checkname'],
-                            detail.outcome)
-
-            output_data.append(outcome)
-
-            # Posting to Bodhi takes a long time. We need to display some progress,
-            # else our tasks might get killed due to inactivity. Print status
-            # for every 20th build, or when complete.
-            if index % 20 == 0 or index == len(check_details):
-                log.info('Bodhi results processed: %d/%d', index,
-                         len(check_details))
-
-        return output_data
-
-
-class BodhiUpdateState:
-    def __init__(self, update_id, kojitag='updates'):
-        self.test_states = {    'depcheck_32':'NORUN',
-                                'depcheck_64':'NORUN',
-                                'upgradepath':'NORUN'
-                           }
-
-        # since upgradepath is only run on updates-pending,
-        # set it to passed if we're working on updates-testing
-        if kojitag == 'updates-testing':
-            self.test_states['upgradepath'] = 'PASSED'
-
-        self.result_history = []
-        self.update_id = update_id
-        self.test_change = False
-
-    def num_results(self):
-        ''' Retrieve the number of results currently held '''
-        return len(self.result_history)
-
-    def add_result(self, new_result):
-        ''' Update the current state with a new result.
-
-            :param dict new_result: a dictionary containing the following keys:
-                ``time`` (datetime object), ``testname``, ``result``, ``arch``
-        '''
-
-        self.result_history.append(new_result)
-
-        # copy the current test state so that we can compare later
-        old_state = self.test_states.copy()
-
-        # for depcheck, we only care about i386 and x86_64 arches
-        # anything else will be ignored
-        if new_result['testname'] == 'depcheck':
-            arch = basearch(new_result['arch'])
-
-            if arch == 'i386':
-                self.test_states['depcheck_32'] = new_result['result']
-
-            elif arch == 'x86_64':
-                self.test_states['depcheck_64'] = new_result['result']
-
-            else:
-                log.info("Arch %s is not valid for depcheck. Ignoring." \
-                    % new_result['arch'])
-
-        # don't care about the arch for upgrade path. It should be noarch
-        # but the results aren't changed if it isn't
-        elif new_result['testname'] == 'upgradepath':
-            self.test_states['upgradepath'] = new_result['result']
-
-        # detect if any tests changed from the last result
-        if old_state != self.test_states:
-            self.test_change = True
-        else:
-            self.test_change = False
-
-    def get_state(self):
-        ''' Determine state based on currently known results '''
-        test_values = set(self.test_states.values())
-        if 'NORUN' in test_values:
-            return INCOMPLETE
-        if 'FAILED' in test_values:
-            return FAIL
-        if 'PASSED' in test_values and len(test_values) == 1:
-            return PASS
-
-        return UNKNOWN
-
-    def get_state_str(self):
-        '''Get state string description to be used in debug logs'''
-        state_str = '  %s' % self.test_states
-        for result in self.result_history:
-            state_str += '\n  %s' % result
-
-        return state_str
-
-    def did_test_change(self):
-        ''' Determine whether the state of any tests changed with the addition
-            of the last result'''
-        return self.test_change
-
-
-def _is_comment_email_needed(update_id, parsed_comments, new_result,
-                                   kojitag):
-    '''
-       Determines whether or not to send an email with the comment posted to bodhi.
-       Uses previous comments on update in order to determine current state
-
-       :param str update_id: ID of the update to be tested
-       :param parsed_comments: already existing Taskotron comments for
-           the update
-       :type parsed_comments: list of dict
-       :param dict new_result: the new result to be posted
-       :param str kojitag: the koji tag being tested (affects the expected tests)
-       :rtype: bool
-    '''
-    # NOTE: Bodhi2 no longer supports forcing or supressing emails:
-    # https://github.com/fedora-infra/bodhi/issues/289
-    # (they might decide to change it, the ticket is not closed yet)
-
-    # compute current state
-    update_state = BodhiUpdateState(update_id, kojitag=kojitag)
-    for result in parsed_comments:
-        update_state.add_result(result)
-
-    current_state = update_state.get_state()
-    log.debug('Current state for %s: %s\n  %s', update_id, current_state,
-              update_state.get_state_str())
-    update_state.add_result(new_result)
-    new_state = update_state.get_state()
-    log.debug('New state for %s: %s\n  %s', update_id, new_state,
-              update_state.get_state_str())
-
-    # by default, we want to send email on state change, so start from there
-    send_email = True
-
-    if new_state is PASS and current_state is not FAIL:
-        send_email = False
-
-    log.debug('Bodhi email needed for %s: %s', update_id,
-              'yes' if send_email else 'no')
-
-    return send_email
-
-
-def _parse_result_from_comment(comment):
-    '''
-       Parses timestamp and results from bodhi comment
-
-       :param dict comment: the ``comment`` part of bodhi update object
-       :rtype: dict
-    '''
-
-    comment_time = datetime.datetime.strptime(comment['timestamp'], '%Y-%m-%d %H:%M:%S')
-
-    # comment form to match:
-    # 'Taskotron: %s test %s on %s. Result log: %s'
-    # note that it isn't looking for the autoqa user right now, that needs to
-    # be done in any code that calls this
-    comment_match = RE_COMMENT.match(comment['text'])
-
-    test_name = ''
-    result = ''
-    arch = ''
-
-    if comment_match:
-        test_name = comment_match.group('test_name')
-        result = comment_match.group('result')
-        arch = comment_match.group('arch')
-    else:
-        log.warning('Failed to parse bodhi comment: %r', comment['text'])
-
-    return {'time':comment_time, 'testname':test_name,
-            'result':result, 'arch':arch}
-
-
-def _already_commented(update, testname, arch):
-    '''Check if Taskotron comment is already posted.
-
-       :param update: Bodhi update object
-       :param str testname: the name of the test
-       :param str arch: tested architecture
-
-       Note: Only NVR allowed, not ENVR. See https://fedorahosted.org/bodhi/ticket/592.
-
-       :return: Tuple containing old result and time when the last comment was posted.
-           If no comment is posted yet, or it is, but the update
-           has been modified since, tuple will contain two empty strings.
-    '''
-
-    Config = config.get_config()
-
-    comment_re = r'Taskotron:[\s]+%s[\s]+test[\s]+(\w+)[\s]+on[\s]+%s' % (testname, arch)
-    old_result = ''
-    comment_time = ''
-
-    taskotron_comments = [comment for comment in update['comments']
-                          if comment['user']['name'] == Config.fas_username]
-    for comment in taskotron_comments:
-        m = re.match(comment_re, comment['text'])
-        if m is None:
-            continue
-        old_result = m.group(1)
-        comment_time = comment['timestamp']
-    # check whether update was modified after the last posted comment
-    if update['date_modified'] > comment_time:
-        return ('','')
-    return (old_result, comment_time)
-
-
-def _is_comment_needed(old_result, comment_time, result, time_span = None):
-    '''Check if the comment is meant to be posted.
-
-       :param str old_result: the result of the last test
-       :param str comment_time: the comment time of the last test
-       :param str result: the result of the test
-       :param int time_span: waiting period (in minutes) before posting the same comment
-
-       :return: ``True`` if the comment will be posted, ``False`` otherwise.
-       :rtype: bool
-    '''
-    # we decided we will post just FAILED results, unless it's a change of state
-    # (e.g. FAILED->PASSED)
-
-    if not old_result:
-        return result == 'FAILED'  # only post FAILED for the initial comment
-
-    if old_result != result:  # change of state
-        return True
-
-    # If we got here, it means that the comment with the same result has been
-    # already posted, we now need to determine whether we can post the
-    # comment again or not.
-    # If the previous result is *not* 'FAILED', we won't post it in order not to
-    # spam developers.
-    # If the previous result *is* 'FAILED', we will need to check whether given
-    # time span expired, if so, we will post the same comment again to remind
-    # a developer about the issue.
-    assert old_result == result
-
-    if result != 'FAILED':
-        return False
-
-    if time_span is None:
-        Config = config.get_config()
-        time_span = Config.bodhi_posting_comments_span
-
-    posted_datetime = datetime.datetime.strptime(comment_time, '%Y-%m-%d %H:%M:%S')
-
-    delta = (datetime.datetime.utcnow() - posted_datetime)
-    # total_seconds() is introduced in python 2.7, until 2.7 is everywhere...
-    delta_minutes = (delta.seconds + delta.days * 24 * 3600) / 60
-
-    if delta_minutes < time_span:
-        return False
-
-    return True
-
-
-def _post_testresult(bodhi_api, updateid, testname, result, url,
-                     arch = 'noarch', karma = 0, doreport='onchange'):
-    '''Post comment and karma to bodhi
-
-       :param str updateid: the ID of the update to comment on
-       :param str testname: the name of the test
-       :param str result: the result of the test
-       :param str url: url of the result of the test
-       :param str arch: tested architecture (default ``noarch``)
-       :param int karma: karma points (default ``0``)
-       :param str doreport: set to 'all' to force posting bodhi comment
-
-       :return: ``True`` if comment was posted successfully or comment wasn't
-           meant to be posted (either posting is turned off or comment was
-           already posted), ``False`` otherwise.
-       :rtype: bool
-    '''
-
-    Config = config.get_config()
-
-    if not updateid or not testname or not result or url is None:
-        log.error("bodhi_post_testresults() requires non-empty updateid, "
-                  "testname, result and url arguments.")
-        return False
-
-    if not Config.fas_username or not Config.fas_password:
-        log.error('Conf file containing FAS credentials is incomplete!')
-        return False
-
-    if result in ['ABORTED', 'CRASHED']:
-        log.debug("Results with outcome of CRASHED or ABORTED are not submitted"
-                  " to bodhi: %s %s" % (updateid, result))
-        return True
-
-    log.debug('Posting a result to Bodhi for: %s', updateid)
-
-    comment = 'Taskotron: %s test %s on %s. Result log: %s ' \
-              '(results are informative only)' % (testname, result, arch, url)
-    try:
-        bodhi_update = bodhi_api.get_update(updateid)
-        if not bodhi_update:
-            # this might happen for old Bodhi1 updates still circulating in the system,
-            # the YAML might not contain `item: updateid` but `item: update_title`
-            log.warning("No update with ID '%s' found, skipping...")
-            return False
-
-        (old_result, comment_time) = _already_commented(bodhi_update, testname, arch)
-        comment_needed = _is_comment_needed(old_result, comment_time, result)
-
-        if not comment_needed and doreport != 'all':
-            log.debug('Bodhi comment is not needed for: %s %s',
-                      updateid, result)
-            return True
-
-        # submit the comment
-        bodhi_api.client.comment(bodhi_update['title'], comment, karma)
-        log.debug('Test result successfully submitted to Bodhi: %s %s',
-                  updateid, result)
-
-    except Exception as e:
-        log.exception(e)
-        return False
-
-    return True
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
@@ -26,8 +26,8 @@
 returns: |
   YAML formatted output as taken from input, enhanced with result-id's for each
   successfully stored result. The result-id information then can be used by
-  other directives - e.g. ``bodhi_comment_directive``. If reporting to ResultsDB
-  is disabled, the returned YAML does not contain this extra field.
+  other directives. If reporting to ResultsDB is disabled, the returned YAML
+  does not contain this extra field.
 raises: |
   * :class:`.TaskotronDirectiveError`: if ``results`` is not in a valid YAML
     format, or when  ``item`` or ``type`` are missing in the YAML's result data
@@ -202,7 +202,7 @@
                     "'item' and 'type' to be present in the YAML data.")
 
         conf = config.get_config()
-        if not (conf.reporting_enabled and conf.report_to_resultsdb):
+        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'])
             return check.export_YAML(check_details)
diff --git a/libtaskotron/ext/fedora/bodhi_utils.py b/libtaskotron/ext/fedora/bodhi_utils.py
--- a/libtaskotron/ext/fedora/bodhi_utils.py
+++ b/libtaskotron/ext/fedora/bodhi_utils.py
@@ -37,9 +37,7 @@
         self.config = config.get_config()
 
         if not client:
-            self.client = fedora.client.bodhi.Bodhi2Client(staging=self.config.bodhi_staging,
-                                                           username=self.config.fas_username,
-                                                           password=self.config.fas_password)
+            self.client = fedora.client.bodhi.Bodhi2Client(staging=self.config.bodhi_staging)
             log.debug('Created Bodhi client to: %s', self.client.base_url)
             # automatically retry failed requests (HTTP 5xx and similar)
             self.client.retries = 10
diff --git a/testing/test_bodhi_comment_directive.py b/testing/test_bodhi_comment_directive.py
deleted file mode 100644
--- a/testing/test_bodhi_comment_directive.py
+++ /dev/null
@@ -1,382 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2009-2014, Red Hat, Inc.
-# License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+>
-# See the LICENSE file for more details on Licensing
-
-"""Unit tests for libtaskotron/directives/resultsdb_directive.py"""
-
-import pytest
-import datetime
-import itertools
-from dingus import Dingus
-from copy import deepcopy
-
-from libtaskotron.directives import bodhi_comment_directive
-from libtaskotron.exceptions import TaskotronDirectiveError, TaskotronValueError
-
-from libtaskotron import check
-from libtaskotron import config
-
-
-@pytest.mark.usefixtures('setup')
-class TestBodhiCommentReport():
-
-    @pytest.fixture
-    def setup(self, monkeypatch):
-        '''Run this before every test invocation'''
-        monkeypatch.setattr(config, '_config', None)
-        Config = config.get_config()
-        Config.reporting_enabled = True
-        Config.report_to_bodhi = True
-
-        self.ref_job_id = 123
-        self.ref_log_url = '%s/builders/all/builds/%d/steps/runtask/logs/stdio'\
-                            % (Config.taskotron_master, self.ref_job_id)
-
-        self.comment = {
-            "user": {'name': Config.fas_username},
-            "timestamp": "2014-01-31 10:11:12",
-            "text": "Taskotron: depcheck test PASSED on x86_64. Result log: %s" % self.ref_log_url,
-            }
-
-        self.update = {
-            'title': 'update title',
-            'request': 'stable',
-            'comments': [self.comment],
-            'date_modified': "2014-01-31 10:00:00"
-            }
-
-        self.stub_bodhi = Dingus(get_update__returns=self.update)
-        self.directive = bodhi_comment_directive.BodhiCommentDirective(self.stub_bodhi)
-
-        self.cd = check.CheckDetail(
-            item='update_id',
-            report_type=check.ReportType.BODHI_UPDATE,
-            outcome='PASSED',
-            )
-
-        yaml = check.export_YAML(self.cd)
-
-        self.ref_input = {
-            'results': yaml,
-            'doreport': 'onchange',
-            }
-        self.ref_envdata = {
-            'checkname': 'depcheck',
-            'jobid': 'all/%d' % self.ref_job_id,
-            }
-
-    def test_config_reporting_disabled(self):
-        """Checks config options can disable reporting."""
-        Config = config.get_config()
-
-        for r_e, r_t_b in ((False, False), (False, True), (True, False)):
-           Config.reporting_enabled = r_e
-           Config.report_to_bodhi = r_t_b
-
-           assert self.directive.process(self.ref_input, self.ref_envdata) 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)
-
-        with pytest.raises(TaskotronDirectiveError):
-            input_data = deepcopy(self.ref_input)
-            del(input_data['doreport'])
-            self.directive.process(input_data, self.ref_envdata)
-
-    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)
-
-    def test_failed_yaml_import(self, monkeypatch):
-        """Checks if failed YAML import raises exception"""
-        def mock_raise(self, *args, **kwargs):
-            raise TaskotronValueError("Testing Error")
-
-        monkeypatch.setattr(check, 'import_YAML', mock_raise)
-
-        with pytest.raises(TaskotronDirectiveError):
-            self.directive.process(self.ref_input, self.ref_envdata)
-
-
-    def test_parse_result_from_comment(self):
-        """Checks parsing of the bodhi comments"""
-        output = bodhi_comment_directive._parse_result_from_comment(self.comment)
-
-        assert output['time'] == datetime.datetime(2014, 1, 31, 10, 11, 12)
-        assert output['testname'] == 'depcheck'
-        assert output['result'] == 'PASSED'
-        assert output['arch'] == 'x86_64'
-
-    def test_already_commented(self):
-        """Tests general _already_commented behaviour."""
-
-        # Test comment found
-        outcome = bodhi_comment_directive._already_commented(self.update, 'depcheck', 'x86_64')
-        assert outcome == ('PASSED', self.comment['timestamp'])
-
-        # Test no comment
-        update = deepcopy(self.update)
-        update['comments'] = []
-        outcome = bodhi_comment_directive._already_commented(update, 'depcheck', 'x86_64')
-        assert outcome == ('', '')
-
-        # Test modified after commented
-        update = deepcopy(self.update)
-        update['date_modified'] = "2014-01-31 15:00:00"
-        outcome = bodhi_comment_directive._already_commented(update, 'depcheck', 'x86_64')
-        assert outcome == ('', '')
-
-    def test_is_comment_needed(self):
-        """Checks whether _is_comment_needed returns proper results in
-        various situations."""
-        # Test first comment FAILED
-        outcome = bodhi_comment_directive._is_comment_needed(None, None, 'FAILED', None)
-        assert outcome is True
-
-        # Test first comment anything else
-        outcome = bodhi_comment_directive._is_comment_needed(None, None, 'PASSED', None)
-        assert outcome is False
-
-        # Test different result
-        outcome = bodhi_comment_directive._is_comment_needed('PASSED', None, 'FAILED', None)
-        assert outcome is True
-        outcome = bodhi_comment_directive._is_comment_needed('FAILED', None, 'PASSED', None)
-        assert outcome is True
-
-        # Test same result, but not FAILED
-        outcome = bodhi_comment_directive._is_comment_needed('PASSED', None, 'PASSED', None)
-        assert outcome is False
-
-    def test_is_comment_needed_decide_repost(self, monkeypatch):
-        """Checks whether time_span has an impact on comment posting."""
-        date_utcnow = datetime.datetime(2014, 01, 10, 12, 05)
-        date_posted = datetime.datetime(2014, 01, 10, 12, 00)
-
-        class FakeDatetime(datetime.datetime):
-            @classmethod
-            def utcnow(cls):
-                return date_utcnow
-
-
-        monkeypatch.setattr(datetime, 'datetime', FakeDatetime)
-
-        # Test same result, FAILED, delta < time_span
-        time_span = 1000
-        comment_time = date_posted.strftime('%Y-%m-%d %H:%M:%S')
-        outcome = bodhi_comment_directive._is_comment_needed('FAILED', comment_time, 'FAILED', time_span)
-        assert outcome is False
-
-        # Test same result, FAILED, delta > time_span
-        time_span = 0
-        comment_time = date_posted.strftime('%Y-%m-%d %H:%M:%S')
-        outcome = bodhi_comment_directive._is_comment_needed('FAILED', comment_time, 'FAILED', time_span)
-        assert outcome is True
-
-    def test_post_testresult_params_and_config(self):
-        """Checks whether missing parameters/config values terminate
-        _post_testresults."""
-        # Test empty parameters
-        outcome = bodhi_comment_directive._post_testresult(Dingus(), updateid=None, testname=None,
-                                                           result=None, url=None)
-        assert outcome is False
-
-        # Test configuration
-        Config = config.get_config()
-        Config.fas_username = None
-        Config.fas_password = None
-        outcome = bodhi_comment_directive._post_testresult(Dingus(), updateid=True,
-                                                           testname=True, result=True, url=True)
-        config._config = None
-        assert outcome is False
-
-    @pytest.fixture
-    def prepare_for_bodhi_comment(self, monkeypatch):
-        """Sets up environment for fake bodhi comment calls"""
-        Config = config.get_config()
-        Config.fas_password = "secret!"
-
-        stub_already_commented = lambda *args, **kwargs: ('', '')
-        stub_return_true = lambda *args, **kwargs: True
-        stub_return_false = lambda *args, **kwargs: False
-
-        monkeypatch.setattr(bodhi_comment_directive, '_already_commented', stub_already_commented)
-        monkeypatch.setattr(bodhi_comment_directive, '_is_comment_needed', stub_return_true)
-        monkeypatch.setattr(bodhi_comment_directive, '_is_comment_email_needed', stub_return_false)
-
-
-    def test_post_testresult_comment_not_needed(self, monkeypatch, prepare_for_bodhi_comment):
-        """Checks the behaviour when comment is not needed."""
-        self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
-
-        monkeypatch.setattr(bodhi_comment_directive, '_is_comment_needed', lambda *a, **k: False)
-
-        outcome = bodhi_comment_directive._post_testresult(
-            self.stub_bodhi, updateid=True, testname=True, result=True, url=True,
-            doreport='onchange')
-        assert outcome is True
-        assert len(self.stub_bodhi.client.calls()) == 0
-
-    def test_post_testresult(self, prepare_for_bodhi_comment):
-        """Checks whether _post_testresult maps arguments correctly to
-        the bodhi comment call."""
-        ref_comment = "Taskotron: depcheck test PASSED on noarch. "\
-                      "Result log: %s (results are informative only)" % self.ref_log_url
-        self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
-
-        bodhi_comment_directive._post_testresult(
-            self.stub_bodhi, updateid="update_id", testname="depcheck", result="PASSED",
-            url=self.ref_log_url)
-
-        # Select the first call of "comment" method.
-        call = [call for call in self.stub_bodhi.client.calls() if call[0] == 'comment'][0]
-        # Select the positional arguments of that call
-        call_data = call[1]
-
-        assert call_data[0] == "update title"
-        assert call_data[1] == ref_comment
-        assert call_data[2] == 0
-
-    def test_post_testresult_aborted(self, prepare_for_bodhi_comment):
-        """Checks whether _post_testresult correctly does not submit comments
-        for ABORTED results."""
-        self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
-
-        bodhi_comment_directive._post_testresult(
-            self.stub_bodhi, updateid="update_id", testname="depcheck", result="ABORTED",
-            url=self.ref_log_url)
-
-        # if the result was properly ignored, this should be empty
-        assert len(self.stub_bodhi.client.calls) == 0
-
-    def test_post_testresult_crashed(self, prepare_for_bodhi_comment):
-        """Checks whether _post_testresult correctly does not submit comments
-        for ABORTED results."""
-        self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
-
-        bodhi_comment_directive._post_testresult(
-            self.stub_bodhi, updateid="update_id", testname="depcheck", result="CRASHED",
-            url=self.ref_log_url)
-
-        # if the result was properly ignored, this should be empty
-        assert len(self.stub_bodhi.client.calls) == 0
-
-    def test_yaml_mapping(self, prepare_for_bodhi_comment):
-        """Checks whether YAML output is mapped correctly to
-        the bodhi comment call."""
-        ref_comment = "Taskotron: depcheck test PASSED on noarch. "\
-                      "Result log: %s (results are informative only)" % self.ref_log_url
-        self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
-
-        self.directive.process(self.ref_input, self.ref_envdata)
-
-        # Select the first call of "comment" method.
-        call = [call for call in self.stub_bodhi.client.calls() if call[0] == 'comment'][0]
-        # Select the positional arguments of that call
-        call_data = call[1]
-
-        assert call_data[0] == "update title"
-        assert call_data[1] == ref_comment
-        assert call_data[2] == 0
-
-    def test_yaml_mapping_resultsdb(self, prepare_for_bodhi_comment):
-        """Checks whether YAML output is mapped correctly to
-        the bodhi comment call when resultsdb_result_id is provided"""
-
-        Config = config.get_config()
-
-        cd = check.CheckDetail(
-            item='update_id',
-            report_type=check.ReportType.BODHI_UPDATE,
-            outcome='PASSED',
-            )
-        cd._internal = {'resultsdb_result_id': 1234}
-        log_url = "%s/results/1234" % Config.resultsdb_frontend
-
-        yaml = check.export_YAML(cd)
-
-        ref_input = {
-            'results': yaml,
-            'doreport': 'onchange',
-            }
-
-        ref_comment = "Taskotron: depcheck test PASSED on noarch. "\
-                      "Result log: %s (results are informative only)" % log_url
-        self.stub_bodhi.client = Dingus('bodhi_api.bodhi')
-
-        self.directive.process(ref_input, self.ref_envdata)
-
-        # Select the first call of "comment" method.
-        call = [call for call in self.stub_bodhi.client.calls() if call[0] == 'comment'][0]
-        # Select the positional arguments of that call
-        call_data = call[1]
-
-        assert call_data[0] == "update title"
-        assert call_data[1] == ref_comment
-        assert call_data[2] == 0
-
-    def test_is_comment_email_needed(self, monkeypatch):
-        def mock_BodhiUpdateState_factory(current_state, new_state):
-
-            class MockBodhiUpdateState(Dingus):
-                def __init__(self, *args, **kwargs):
-                    Dingus.__init__(self, *args, **kwargs)
-                    self.state = current_state
-
-                def add_result(self, *args, **kwargs):
-                    self.state = new_state
-
-                def get_state(self):
-                    return self.state
-
-            return MockBodhiUpdateState
-
-        PASS = bodhi_comment_directive.PASS
-        FAIL = bodhi_comment_directive.FAIL
-        INCOMPLETE = bodhi_comment_directive.INCOMPLETE
-        UNKNOWN = bodhi_comment_directive.UNKNOWN
-
-
-        # if new_state is PASS and the current_state was not 'FAIL', do not send email
-        for current_state in (PASS, INCOMPLETE, UNKNOWN):
-            mock_bus = mock_BodhiUpdateState_factory(current_state, PASS)
-            monkeypatch.setattr(bodhi_comment_directive, 'BodhiUpdateState', mock_bus)
-
-            outcome = bodhi_comment_directive._is_comment_email_needed(None, [], None, None)
-            assert outcome is False
-
-        # If current_state is FAIL, send email
-        for new_state in (PASS, FAIL, INCOMPLETE, UNKNOWN):
-            mock_bus = mock_BodhiUpdateState_factory(FAIL, new_state)
-            monkeypatch.setattr(bodhi_comment_directive, 'BodhiUpdateState', mock_bus)
-
-            outcome = bodhi_comment_directive._is_comment_email_needed(None, [], None, None)
-            assert outcome is True
-
-        # If new_state is not PASS and current_state is not FAIL, send email
-        new_states = (FAIL, INCOMPLETE, UNKNOWN)
-        current_states = (PASS, INCOMPLETE, UNKNOWN)
-
-        for current_state, new_state in itertools.product(current_states, new_states):
-            mock_bus = mock_BodhiUpdateState_factory(current_state, new_state)
-            monkeypatch.setattr(bodhi_comment_directive, 'BodhiUpdateState', mock_bus)
-
-            outcome = bodhi_comment_directive._is_comment_email_needed(None, [], None, None)
-            assert outcome is True
-
-
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
@@ -69,24 +69,21 @@
         # while it appears useless, this actually sets config in several tests
         monkeypatch.setattr(config, '_config', None)
         self.conf = config.get_config()
-        self.conf.reporting_enabled = True
         self.conf.report_to_resultsdb = True
 
 
     def test_config_reporting_disabled(self):
-        """Checks config options can disable reporting."""
+        """Checks config option that disables 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
+        conf.report_to_resultsdb = False
 
-            yaml = self.test_rdb.process(self.ref_input, self.ref_envdata)
-            cds = check.import_YAML(yaml)
-            my_cd = check.import_YAML(check.export_YAML(self.cd))
-            # return value should be the same YAML
-            assert len(cds) == 1
-            assert cds[0].__dict__ == my_cd[0].__dict__
+        yaml = self.test_rdb.process(self.ref_input, self.ref_envdata)
+        cds = check.import_YAML(yaml)
+        my_cd = check.import_YAML(check.export_YAML(self.cd))
+        # return value should be the same YAML
+        assert len(cds) == 1
+        assert cds[0].__dict__ == my_cd[0].__dict__
 
         # no call should have been made
         assert len(self.stub_rdb.calls()) == 0

