diff --git a/conf/trigger.cfg.example b/conf/trigger.cfg.example
--- a/conf/trigger.cfg.example
+++ b/conf/trigger.cfg.example
@@ -2,14 +2,12 @@
 url = http://localhost:8080/buildbot/change_hook
 
 [trigger]
-koji_tasks = rpmlint
-bodhi_to_koji_tag_tasks = upgradepath,depcheck
-bodhi_tasks = examplebodhi
+koji_build_completed_tasks = rpmlint
+koji_tag_changed_tasks = upgradepath,depcheck
 valid_arches = i386,i686,x86_64,noarch
 koji_url = http://koji.fedoraproject.org/kojihub
 type = StreamTrigger
-blacklist_releases = el5,el6
+blacklist_releases = el5,el6,el7
 job_logging = False
 joblog_file = /var/log/taskotron-trigger/jobs.csv
 fuse_delay = 1000 ; seconds
-x86_64_only = depcheck
diff --git a/fedmsg.d/taskotron-trigger.py b/fedmsg.d/taskotron-trigger.py
--- a/fedmsg.d/taskotron-trigger.py
+++ b/fedmsg.d/taskotron-trigger.py
@@ -1,4 +1,4 @@
 config = {
-    'taskotron.kojijobtrigger.enabled': True,
-    'taskotron.bodhijobtrigger.enabled': True,
+    'taskotron.kojitagchangedjobtrigger.enabled': True,
+    'taskotron.kojibuildcompletedjobtrigger.enabled': True,
 }
diff --git a/jobtriggers/__init__.py b/jobtriggers/__init__.py
--- a/jobtriggers/__init__.py
+++ b/jobtriggers/__init__.py
@@ -10,10 +10,6 @@
     def trigger_tasks(self, item, item_type, tasks, arches):
         for task in tasks:
             for arch in arches:
-                # XXX hack T256
-                if task in config.x86_64_only and arch != "x86_64":
-                    continue
-
                 self.log.info('triggering %s for %s on %s', task, item, arch)
 
                 if config.job_logging:
diff --git a/jobtriggers/bodhi_msg.py b/jobtriggers/bodhi_msg.py
deleted file mode 100644
--- a/jobtriggers/bodhi_msg.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import fedmsg
-import fedmsg.encoding
-import moksha.hub.reactor
-
-from twisted.internet.task import LoopingCall
-
-from . import utils, config
-from . import JobTrigger
-
-class BodhiJobTrigger(JobTrigger):
-    topic = "org.fedoraproject.prod.bodhi.update.request.*"
-    jsonify = False
-    config_key = 'taskotron.bodhijobtrigger.enabled'
-
-    def __init__(self, *args, **kw):
-        super(BodhiJobTrigger, self).__init__(*args, **kw)
-
-        self.queued_tags = set()
-        self.queued_arches = set()
-
-        # check for bodhi_to_koji_tags tasks queue every config.fuse_delay seconds
-        lc = LoopingCall(self.delayed_consume)
-        lc.start(config.fuse_delay)
-
-    def delayed_consume(self):
-        if self.queued_tags:
-            try:
-                for tag in self.queued_tags:
-                    self.trigger_tasks(tag, 'koji_tag', config.bodhi_to_koji_tag_tasks, self.queued_arches)
-            finally:
-                self.queued_tags = set()
-                self.queued_arches = set()
-        else:
-            self.log.debug("Woke up, but there were no messages.")
-
-    def consume(self, message):
-        usable_message = fedmsg.encoding.loads(message.body)
-
-        topic = usable_message['topic']
-        builds = usable_message['msg']['update']['builds']
-        nvrs = [build['nvr'] for build in builds]
-
-        # we want only requests to stable and testing
-        if not topic.endswith('stable') and not topic.endswith('testing'):
-            return
-
-        # do not schledule jobs for blacklisted releases
-        if nvrs[0].endswith(tuple(config.blacklist_releases)):
-            return
-
-        updatetitle = usable_message['msg']['update']['title']
-        arches = utils.get_arches(nvr=nvrs[0])
-
-        # XXX T252
-        # only schedule koji_tag tasks for -pending tags
-        if usable_message['msg']['update']['status'] == 'pending':
-            dist_tag = usable_message['msg']['update']['release']['dist_tag']
-
-            koji_tag = '%s-updates' % dist_tag
-            if topic.endswith('testing'):
-                koji_tag += '-testing'
-            koji_tag += '-pending'
-
-            if not len(self.queued_tags):
-                self.log.info('setting fuse (%d seconds) for koji_tag %s', config.fuse_delay, koji_tag)
-            else:
-                self.log.info('adding koji_tag %s to the fuse queue', koji_tag)
-
-            self.queued_tags.add(koji_tag)
-            for arch in arches:
-                self.queued_arches.add(arch)
-
-        # run bodhi_id tasks for every update
-        self.trigger_tasks(updatetitle, 'bodhi_id', config.bodhi_tasks, arches)
diff --git a/jobtriggers/config.py b/jobtriggers/config.py
--- a/jobtriggers/config.py
+++ b/jobtriggers/config.py
@@ -6,36 +6,30 @@
 url = http://localhost:8080/buildbot/change_hook
 
 [trigger]
-koji_tasks = rpmlint
-bodhi_to_koji_tag_tasks = upgradepath,depcheck
-bodhi_tasks = examplebodhi
+koji_build_completed_tasks = rpmlint
+koji_tag_changed_tasks = upgradepath,depcheck
 valid_arches = i386,i686,x86_64,noarch
 koji_url = http://koji.fedoraproject.org/kojihub
 type = StreamTrigger
-blacklist_releases = el5,el6
+blacklist_releases = el5,el6,el7
 job_logging = False
 joblog_file = /var/log/taskotron-trigger/jobs.cvs
 fuse_delay = 1000 ; seconds
-x86_64_only = depcheck
 """
 
 config = ConfigParser.ConfigParser()
 config.readfp(io.BytesIO(defaults))
 config.read(['/etc/taskotron/trigger.cfg', './conf/trigger.cfg'])
 
 
-buildbot_username = config.get('buildbot', 'username')
-buildbot_password = config.get('buildbot', 'password')
 buildbot_url = config.get('buildbot', 'url')
 
-koji_tasks = [e.strip() for e in config.get('trigger', 'koji_tasks').split(',')]
-bodhi_to_koji_tag_tasks = [e.strip() for e in config.get('trigger', 'bodhi_to_koji_tag_tasks').split(',')]
-bodhi_tasks = [e.strip() for e in config.get('trigger', 'bodhi_tasks').split(',')]
+koji_build_completed_tasks = [e.strip() for e in config.get('trigger', 'koji_build_completed_tasks').split(',')]
+koji_tag_changed_tasks = [e.strip() for e in config.get('trigger', 'koji_tag_changed_tasks').split(',')]
 valid_arches = [e.strip() for e in config.get('trigger', 'valid_arches').split(',')]
 koji_url = config.get('trigger', 'koji_url')
 trigger_type = config.get('trigger', 'type')
 blacklist_releases = [e.strip() for e in config.get('trigger', 'blacklist_releases').split(',')]
 job_logging = True if config.get('trigger', 'job_logging') == 'True' else False
 joblog_file = config.get('trigger', 'joblog_file')
 fuse_delay = int(config.get('trigger', 'fuse_delay')) # seconds
-x86_64_only = [e.strip() for e in config.get('trigger', 'x86_64_only').split(',')]
diff --git a/jobtriggers/koji_msg.py b/jobtriggers/koji_build_msg.py
rename from jobtriggers/koji_msg.py
rename to jobtriggers/koji_build_msg.py
--- a/jobtriggers/koji_msg.py
+++ b/jobtriggers/koji_build_msg.py
@@ -1,27 +1,28 @@
+import koji
 import fedmsg
 import fedmsg.encoding
 
 from . import utils, config
 from . import JobTrigger
 
 ITEM_TYPE = 'koji_build'
 
-class KojiJobTrigger(JobTrigger):
-    topic = "org.fedoraproject.prod.buildsys.tag"
+class KojiBuildCompletedJobTrigger(JobTrigger):
+    topic = "org.fedoraproject.prod.buildsys.build.state.change"
     jsonify = False
-    config_key = 'taskotron.kojijobtrigger.enabled'
+    config_key = 'taskotron.kojibuildcompletedjobtrigger.enabled'
 
     def __init__(self, *args, **kw):
-        super(KojiJobTrigger, self).__init__(*args, **kw)
+        super(KojiBuildCompletedJobTrigger, self).__init__(*args, **kw)
 
     def consume(self, message):
         usable_message = fedmsg.encoding.loads(message.body)
 
-        tag = usable_message['msg']['tag']
         release = usable_message['msg']['release']
+        state = usable_message['msg']['new']
 
-        # we look only for pending builds
-        if not tag.endswith('pending'):
+        # we only look for successfuly completed builds
+        if state != koji.BUILD_STATES['COMPLETE']:
             return
 
         # do not schledule jobs for blacklisted releases
@@ -36,4 +37,4 @@
 
         arches = utils.get_arches(buildid=buildid)
 
-        self.trigger_tasks(envr, ITEM_TYPE, config.koji_tasks, arches)
+        self.trigger_tasks(envr, ITEM_TYPE, config.koji_build_completed_tasks, arches)
diff --git a/jobtriggers/koji_tag_msg.py b/jobtriggers/koji_tag_msg.py
new file mode 100644
--- /dev/null
+++ b/jobtriggers/koji_tag_msg.py
@@ -0,0 +1,52 @@
+import fedmsg
+import fedmsg.encoding
+import moksha.hub.reactor
+
+from twisted.internet.task import LoopingCall
+
+from . import config
+from . import JobTrigger
+
+ITEM_TYPE = 'koji_tag'
+
+class KojiTagChangedJobTrigger(JobTrigger):
+    topic = "org.fedoraproject.prod.buildsys.tag"
+    jsonify = False
+    config_key = 'taskotron.kojitagchangedjobtrigger.enabled'
+
+    def __init__(self, *args, **kw):
+        super(KojiTagChangedJobTrigger, self).__init__(*args, **kw)
+
+        self.queued_tags = set()
+
+        # check for bodhi_to_koji_tags tasks queue every config.fuse_delay seconds
+        lc = LoopingCall(self.delayed_consume)
+        lc.start(config.fuse_delay)
+
+    def delayed_consume(self):
+        if self.queued_tags:
+            try:
+                for tag in self.queued_tags:
+                    # it is sufficient to run depcheck and upgradepath only on one arch
+                    # XXX hardcoding X86_64
+                    self.trigger_tasks(tag, ITEM_TYPE, config.koji_tag_changed_tasks, ['x86_64'])
+            finally:
+                self.queued_tags = set()
+        else:
+            self.log.debug("Woke up, but there were no messages.")
+
+    def consume(self, message):
+        usable_message = fedmsg.encoding.loads(message.body)
+
+        koji_tag = usable_message['msg']['tag']
+
+        # we want only pending tags
+        if not koji_tag.endswith('pending'):
+            return
+
+        if not len(self.queued_tags):
+            self.log.info('setting fuse (%d seconds) for koji_tag %s', config.fuse_delay, koji_tag)
+        else:
+            self.log.info('adding koji_tag %s to the fuse queue', koji_tag)
+
+        self.queued_tags.add(koji_tag)
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -24,8 +24,8 @@
     entry_points={
         'console_scripts': ['jobrunner=jobtriggers.jobrunner:main'],
         'moksha.consumer': (
-            'kojijobtrigger = jobtriggers.koji_msg:KojiJobTrigger',
-            'bodhijobtrigger = jobtriggers.bodhi_msg:BodhiJobTrigger',
+            'kojibuildcompletedjobtrigger = jobtriggers.koji_build_msg:KojiBuildCompletedJobTrigger',
+            'kojitagchangedjobtrigger = jobtriggers.koji_tag_msg:KojiTagChangedJobTrigger',
         ),
     },
     include_package_data=True,
diff --git a/testing/functest_cli.py b/testing/functest_cli.py
--- a/testing/functest_cli.py
+++ b/testing/functest_cli.py
@@ -1,7 +1,7 @@
 import pytest
 from dingus import Dingus
 
-import jobtriggers.cli
+import jobtriggers.jobrunner
 from jobtriggers.utils import log_job
 
 
@@ -16,14 +16,14 @@
         f = tmpdir.join('jobs.csv')
         filename = str(f.realpath())
 
-        monkeypatch.setattr(jobtriggers.cli, 'TRIGGER', Dingus())
+        monkeypatch.setattr(jobtriggers.jobrunner, 'TRIGGER', Dingus())
 
         log_job(filename, self.ref_tests[0], self.ref_unit_types[0], self.ref_nvr, self.ref_arch)
         log_job(filename, self.ref_tests[1], self.ref_unit_types[1], self.ref_nvr, self.ref_arch)
 
-        jobtriggers.cli.run_jobs(filename)
+        jobtriggers.jobrunner.run_jobs(filename)
 
-        trigger_calls = jobtriggers.cli.TRIGGER.trigger_job.calls()
+        trigger_calls = jobtriggers.jobrunner.TRIGGER.trigger_job.calls()
 
         assert len(trigger_calls) == 2
 
diff --git a/testing/test_bodhi_trigger.py b/testing/test_bodhi_trigger.py
deleted file mode 100644
--- a/testing/test_bodhi_trigger.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import pytest
-from dingus import Dingus
-from bunch import Bunch
-
-from jobtriggers import bodhi_msg
-
-
-@pytest.mark.usefixtures('prepare')
-class TestBodhiJobTrigger():
-    @pytest.fixture
-    def prepare(self, monkeypatch):
-        self.ref_updatetitle = 'foo'
-        self.ref_dist_tag = 'f18'
-        self.ref_koji_tag = '%s-updates-pending' % self.ref_dist_tag
-        self.ref_nvr = "gnome-settings-daemon-3.6.1-1.fc18"
-        self.ref_topic = 'org.fedoraproject.prod.bodhi.update.request.stable'
-        self.ref_status = 'pending'
-
-        self.ref_tasks = ['bodhi_task1', 'bodhi_task2']
-        self.ref_validarches = ['i386', 'x86_64']
-        self.ref_blacklist_releases= ['el5', 'el6']
-
-        self._create_msg(self.ref_updatetitle, self.ref_dist_tag, self.ref_nvr, self.ref_topic, self.ref_status)
-
-        stub_hub = Bunch(config=Bunch(get=0))
-        self.helper = bodhi_msg.BodhiJobTrigger(stub_hub)
-
-        self.helper.trigger = Dingus()
-
-        monkeypatch.setattr(bodhi_msg.utils, 'get_arches', lambda *a, **k: self.ref_validarches)
-
-        bodhi_msg.config.bodhi_tasks = self.ref_tasks
-        bodhi_msg.config.bodhi_to_koji_tag_tasks = self.ref_tasks
-        bodhi_msg.config.valid_arches = self.ref_validarches
-        bodhi_msg.config.blacklist_releases = self.ref_blacklist_releases
-        bodhi_msg.config.job_logging = False
-        bodhi_msg.config.x86_64_only = 'bodhi_task1'
-
-    def _create_msg(self, ref_updatetitle, ref_dist_tag, ref_nvr, ref_topic, ref_status):
-        self.ref_message = Bunch(body='{"msg": {"agent": "lmacken",\
-                                        "update": {"submitter": "lmacken",\
-                                                   "title": "%s",\
-                                                   "release": {"dist_tag": "%s"},\
-                                                   "builds": [{"nvr": "%s"}],\
-                                                   "status": "%s"}},\
-                                        "topic": "%s"}' %
-                                        (ref_updatetitle, ref_dist_tag, ref_nvr, ref_status, ref_topic))
-
-    def test_consume(self):
-        self.helper.consume(self.ref_message)
-
-        trigger_calls = self.helper.trigger.trigger_job.calls()
-
-        assert len(trigger_calls) == 3
-
-        assert trigger_calls[0][1] == (self.ref_updatetitle, 'bodhi_id', self.ref_tasks[0], self.ref_validarches[1])
-        assert trigger_calls[1][1] == (self.ref_updatetitle, 'bodhi_id', self.ref_tasks[1], self.ref_validarches[0])
-        assert trigger_calls[2][1] == (self.ref_updatetitle, 'bodhi_id', self.ref_tasks[1], self.ref_validarches[1])
-
-    def test_consume_delayed_queues(self):
-        self.helper.consume(self.ref_message)
-
-        assert self.helper.queued_tags == set([self.ref_koji_tag])
-        assert self.helper.queued_arches == set(self.ref_validarches)
-
-    def test_consume_delayed_queues_kojitag_not_pending(self):
-        ref_status = ''
-        self._create_msg(self.ref_updatetitle, self.ref_dist_tag, self.ref_nvr, self.ref_topic, ref_status)
-        self.helper.consume(self.ref_message)
-
-        assert self.helper.queued_tags == set()
-        assert self.helper.queued_arches == set()
-
-    def test_consume_notwatched_topic(self):
-        ref_topic = 'org.fedoraproject.pro.bodhi.update.request.randomtopic'
-        self._create_msg(self.ref_updatetitle, self.ref_dist_tag, self.ref_nvr, ref_topic, self.ref_status)
-
-        self.helper.consume(self.ref_message)
-
-        trigger_calls = self.helper.trigger.trigger_job.calls()
-
-        assert trigger_calls == []
-
-    def test_consume_blacklisted_release(self):
-        ref_nvr = 'gnome-settings-daemon-3.6.1-1.el5'
-        self._create_msg(self.ref_updatetitle, self.ref_dist_tag, ref_nvr, self.ref_topic, self.ref_status)
-
-        self.helper.consume(self.ref_message)
-
-        trigger_calls = self.helper.trigger.trigger_job.calls()
-
-        assert trigger_calls == []
-
-    def test_consume_kojitag_testing(self):
-        ref_topic = 'org.fedoraproject.pro.bodhi.update.request.testing'
-        self._create_msg(self.ref_updatetitle, self.ref_dist_tag, self.ref_nvr, ref_topic, self.ref_status)
-
-        self.helper.consume(self.ref_message)
-
-        assert 'f18-updates-testing-pending' in self.helper.queued_tags
-
-    def test_delayed_consume(self):
-        self.helper.queued_tags = [self.ref_koji_tag]
-        self.helper.queued_arches = self.ref_validarches
-
-        self.helper.delayed_consume()
-
-        trigger_calls = self.helper.trigger.trigger_job.calls()
-
-        assert len(trigger_calls) == 3
-
-        assert trigger_calls[0][1] == (self.ref_koji_tag, 'koji_tag', self.ref_tasks[0], self.ref_validarches[1])
-        assert trigger_calls[1][1] == (self.ref_koji_tag, 'koji_tag', self.ref_tasks[1], self.ref_validarches[0])
-        assert trigger_calls[2][1] == (self.ref_koji_tag, 'koji_tag', self.ref_tasks[1], self.ref_validarches[1])
-
-        assert self.helper.queued_tags == set()
-        assert self.helper.queued_arches == set()
diff --git a/testing/test_koji_build_trigger.py b/testing/test_koji_build_trigger.py
new file mode 100644
--- /dev/null
+++ b/testing/test_koji_build_trigger.py
@@ -0,0 +1,79 @@
+import koji
+import pytest
+from dingus import Dingus
+from bunch import Bunch
+
+from jobtriggers import koji_build_msg
+
+
+@pytest.mark.usefixtures('prepare')
+class TestKojiBuildCompletedJobTrigger():
+    @pytest.fixture
+    def prepare(self, monkeypatch):
+        self.ref_new = koji.BUILD_STATES['COMPLETE']
+        self.ref_name = 'stage'
+        self.ref_version = '4.1.1'
+        self.ref_release = '3.fc18'
+        self.ref_nvr = '%s-%s-%s' % (self.ref_name, self.ref_version, self.ref_release)
+
+        self._create_msg(self.ref_new, self.ref_name, self.ref_release, self.ref_version)
+
+        self.ref_tasks = ['koji_build_task1', 'koji_build_task2']
+        self.ref_validarches = ['i386', 'x86_64']
+        self.ref_blacklist_releases= ['el5', 'el6']
+
+        stub_hub = Bunch(config=Bunch(get=0))
+
+        self.helper = koji_build_msg.KojiBuildCompletedJobTrigger(stub_hub)
+        self.helper.trigger = Dingus()
+
+        monkeypatch.setattr(koji_build_msg.utils, 'get_arches', lambda *a, **k: self.ref_validarches)
+
+        koji_build_msg.config.koji_build_completed_tasks = self.ref_tasks
+        koji_build_msg.config.valid_arches = self.ref_validarches
+        koji_build_msg.config.blacklist_releases = self.ref_blacklist_releases
+        koji_build_msg.config.job_logging = False
+
+    def _create_msg(self, ref_new, ref_name, ref_release, ref_version):
+        self.ref_message = Bunch(body='{"i": 1,\
+                                        "msg": {"build_id": 221146,\
+                                                "new": %d,\
+                                                "name": "%s",\
+                                                "release": "%s",\
+                                                "version": "%s"},\
+                                        "timestamp": 1359603469.21164,\
+                                        "topic": "org.fedoraproject.prod.buildsys.build.state.change",\
+                                        "username": "apache"}' %
+                                        (ref_new, ref_name, ref_release, ref_version))
+
+    def test_consume(self):
+        self.helper.consume(self.ref_message)
+
+        trigger_calls = self.helper.trigger.trigger_job.calls()
+
+        assert len(trigger_calls) == 4
+
+        assert trigger_calls[0][1] == (self.ref_nvr, koji_build_msg.ITEM_TYPE, self.ref_tasks[0], self.ref_validarches[0])
+        assert trigger_calls[1][1] == (self.ref_nvr, koji_build_msg.ITEM_TYPE, self.ref_tasks[0], self.ref_validarches[1])
+        assert trigger_calls[2][1] == (self.ref_nvr, koji_build_msg.ITEM_TYPE, self.ref_tasks[1], self.ref_validarches[0])
+        assert trigger_calls[3][1] == (self.ref_nvr, koji_build_msg.ITEM_TYPE, self.ref_tasks[1], self.ref_validarches[1])
+
+    def test_consume_notcomplete_state(self):
+        ref_new = koji.BUILD_STATES['BUILDING']
+        self._create_msg(ref_new, self.ref_name, self.ref_release, self.ref_version)
+
+        self.helper.consume(self.ref_message)
+
+        trigger_calls = self.helper.trigger.trigger_job.calls()
+
+        assert trigger_calls == []
+
+    def test_consume_blacklisted_release(self):
+        ref_release = '3.el5'
+        self._create_msg(self.ref_new, self.ref_name, ref_release, self.ref_version)
+
+        self.helper.consume(self.ref_message)
+
+        trigger_calls = self.helper.trigger.trigger_job.calls()
+
+        assert trigger_calls == []
diff --git a/testing/test_koji_trigger.py b/testing/test_koji_tag_trigger.py
rename from testing/test_koji_trigger.py
rename to testing/test_koji_tag_trigger.py
--- a/testing/test_koji_trigger.py
+++ b/testing/test_koji_tag_trigger.py
@@ -2,36 +2,32 @@
 from dingus import Dingus
 from bunch import Bunch
 
-from jobtriggers import koji_msg
+from jobtriggers import koji_tag_msg
 
 
 @pytest.mark.usefixtures('prepare')
-class TestKojiJobTrigger():
+class TestKojiTagChangedJobTrigger():
     @pytest.fixture
     def prepare(self, monkeypatch):
         self.ref_name = 'stage'
         self.ref_version = '4.1.1'
         self.ref_release = '3.fc18'
-        self.ref_nvr = '%s-%s-%s' % (self.ref_name, self.ref_version, self.ref_release)
         self.ref_tag = 'f18-updates-testing-pending'
+        self.ref_nvr = '%s-%s-%s' % (self.ref_name, self.ref_version, self.ref_release)
 
-        self._create_msg(self.ref_name, self.ref_release, self.ref_tag, self.ref_version)
-
-        self.ref_tasks = ['koji_task1', 'koji_task2']
-        self.ref_validarches = ['i386', 'x86_64']
+        self.ref_tasks = ['koji_tag_task1', 'koji_tag_task2']
+        self.ref_arch = 'x86_64'
         self.ref_blacklist_releases= ['el5', 'el6']
 
+        self._create_msg(self.ref_name, self.ref_release, self.ref_tag, self.ref_version)
+
         stub_hub = Bunch(config=Bunch(get=0))
+        self.helper = koji_tag_msg.KojiTagChangedJobTrigger(stub_hub)
 
-        self.helper = koji_msg.KojiJobTrigger(stub_hub)
         self.helper.trigger = Dingus()
 
-        monkeypatch.setattr(koji_msg.utils, 'get_arches', lambda *a, **k: self.ref_validarches)
-
-        koji_msg.config.koji_tasks = self.ref_tasks
-        koji_msg.config.valid_arches = self.ref_validarches
-        koji_msg.config.blacklist_releases = self.ref_blacklist_releases
-        koji_msg.config.job_logging = False
+        koji_tag_msg.config.koji_tag_changed_tasks = self.ref_tasks
+        koji_tag_msg.config.job_logging = False
 
     def _create_msg(self, ref_name, ref_release, ref_tag, ref_version):
         self.ref_message = Bunch(body='{"i": 1,\
@@ -48,34 +44,28 @@
                                         "username": "apache"}' %
                                         (ref_name, ref_release, ref_tag, ref_version))
 
-    def test_consume(self):
+    def test_delayed_queue(self):
         self.helper.consume(self.ref_message)
 
-        trigger_calls = self.helper.trigger.trigger_job.calls()
-
-        assert len(trigger_calls) == 4
-
-        assert trigger_calls[0][1] == (self.ref_nvr, koji_msg.ITEM_TYPE, self.ref_tasks[0], self.ref_validarches[0])
-        assert trigger_calls[1][1] == (self.ref_nvr, koji_msg.ITEM_TYPE, self.ref_tasks[0], self.ref_validarches[1])
-        assert trigger_calls[2][1] == (self.ref_nvr, koji_msg.ITEM_TYPE, self.ref_tasks[1], self.ref_validarches[0])
-        assert trigger_calls[3][1] == (self.ref_nvr, koji_msg.ITEM_TYPE, self.ref_tasks[1], self.ref_validarches[1])
+        assert self.helper.queued_tags == set([self.ref_tag])
 
-    def test_consume_notwatched_tag(self):
-        ref_tag = 'f18-randomtag'
-        self._create_msg(self.ref_name, self.ref_release, ref_tag, self.ref_version)
+    def test_delayed_consume(self):
+        self.helper.queued_tags = [self.ref_tag]
 
-        self.helper.consume(self.ref_message)
+        self.helper.delayed_consume()
 
         trigger_calls = self.helper.trigger.trigger_job.calls()
 
-        assert trigger_calls == []
+        assert len(trigger_calls) == 2
 
-    def test_consume_blacklisted_release(self):
-        ref_release = '3.el5'
-        self._create_msg(self.ref_name, ref_release, self.ref_tag, self.ref_version)
+        assert trigger_calls[0][1] == (self.ref_tag, koji_tag_msg.ITEM_TYPE, self.ref_tasks[0], self.ref_arch)
+        assert trigger_calls[1][1] == (self.ref_tag, koji_tag_msg.ITEM_TYPE, self.ref_tasks[1], self.ref_arch)
 
-        self.helper.consume(self.ref_message)
+        assert self.helper.queued_tags == set()
 
-        trigger_calls = self.helper.trigger.trigger_job.calls()
+    def test_consume_kojitag_not_pending(self):
+        ref_tag = 'f18-updates-testing'
+        self._create_msg(self.ref_name, self.ref_release, ref_tag, self.ref_version)
+        self.helper.consume(self.ref_message)
 
-        assert trigger_calls == []
+        assert self.helper.queued_tags == set()

