diff --git a/tests/vendors/test_handler.py b/tests/vendors/test_handler.py
new file mode 100644
index 0000000000000000000000000000000000000000..c08f35ddb416ffbb4e1bd3f519dc9f3cc266e006
--- /dev/null
+++ b/tests/vendors/test_handler.py
@@ -0,0 +1,110 @@
+# -*- coding: utf-8; -*-
+
+from __future__ import unicode_literals, absolute_import
+
+from unittest import TestCase
+
+import sqlalchemy as sa
+
+from rattail.vendors import handler as mod
+from rattail.vendors.catalogs import CatalogParserNotFound
+from rattail.config import make_config
+from rattail.db import Session
+
+
+class TestVendorHandler(TestCase):
+
+    def setUp(self):
+        self.config = self.make_config()
+        self.handler = self.make_handler()
+
+    def make_config(self):
+        return make_config([], extend=False)
+
+    def make_handler(self):
+        return mod.VendorHandler(self.config)
+
+    def test_choice_uses_dropdown(self):
+        
+        # do not use dropdown by default
+        result = self.handler.choice_uses_dropdown()
+        self.assertFalse(result)
+
+        # but do use dropdown if so configured
+        self.config.setdefault('rattail', 'vendors.choice_uses_dropdown',
+                               'true')
+        result = self.handler.choice_uses_dropdown()
+        self.assertTrue(result)
+
+    def test_get_vendor(self):
+        engine = sa.create_engine('sqlite://')
+        model = self.config.get_model()
+        model.Base.metadata.create_all(bind=engine)
+        session = Session(bind=engine)
+        app = self.config.get_app()
+
+        # no vendor if none exist yet!
+        result = self.handler.get_vendor(session, 'acme')
+        self.assertIsNone(result)
+
+        # let's make the vendor and make sure uuid fetch works
+        uuid = app.make_uuid()
+        acme = model.Vendor(uuid=uuid, name="Acme")
+        session.add(acme)
+        result = self.handler.get_vendor(session, uuid)
+        self.assertIs(result, acme)
+
+        # if we search by key it still does not work
+        result = self.handler.get_vendor(session, 'acme')
+        self.assertIsNone(result)
+
+        # but we can configure the key reference, then it will
+        setting = model.Setting(name='rattail.vendor.acme', value=uuid)
+        session.add(setting)
+        result = self.handler.get_vendor(session, 'acme')
+        self.assertIs(result, acme)
+
+    def test_get_all_catalog_parsers(self):
+
+        # some are always installed; make sure they come back
+        Parsers = self.handler.get_all_catalog_parsers()
+        self.assertTrue(len(Parsers))
+
+    def test_get_supported_catalog_parsers(self):
+
+        # by default all parsers are considered supported, so these
+        # calls should effectively yield the same result
+        all_parsers = self.handler.get_all_catalog_parsers()
+        supported = self.handler.get_supported_catalog_parsers()
+        self.assertEqual(len(all_parsers), len(supported))
+
+        # now pretend only one is supported, using legacy setting
+        self.config.setdefault('tailbone', 'batch.vendorcatalog.supported_parsers',
+                               'rattail.contrib.generic')
+        supported = self.handler.get_supported_catalog_parsers()
+        self.assertEqual(len(supported), 1)
+        Parser = supported[0]
+        self.assertEqual(Parser.key, 'rattail.contrib.generic')
+
+        # now pretend two are supported, using preferred setting
+        self.config.setdefault('rattail', 'vendors.supported_catalog_parsers',
+                               'rattail.contrib.generic, rattail.contrib.kehe')
+        supported = self.handler.get_supported_catalog_parsers()
+        self.assertEqual(len(supported), 2)
+        keys = [Parser.key for Parser in supported]
+        self.assertEqual(keys, ['rattail.contrib.generic', 'rattail.contrib.kehe'])
+
+    def test_get_catalog_parser(self):
+        
+        # generic parser comes back fine
+        parser = self.handler.get_catalog_parser('rattail.contrib.generic')
+        self.assertIsNotNone(parser)
+        self.assertEqual(parser.key, 'rattail.contrib.generic')
+
+        # unknown key returns nothing
+        parser = self.handler.get_catalog_parser('this_should_not_exist')
+        self.assertIsNone(parser)
+
+        # and can raise an error if we require
+        self.assertRaises(CatalogParserNotFound, self.handler.get_catalog_parser,
+                          'this_should_not_exist', require=True)