"""

pyscovery.add_module(module)

gen = pyscovery.find(Plugin, recurse, instantiate)

test.assertTrue(inspect.isgenerator(gen))

found = list(gen)

test.assertEqual(len(found), count, 'plugins found: {}'.format(len(found)))

if instantiate:

for plugin in found:

test.assertIsInstance(plugin, Plugin)

return found

def _test_module_count(test, count):

"""

Asserts if the number of paths doesn't match count

"""

modules = pyscovery.get_modules()

test.assertEqual(len(modules), count, 'search paths {}'.format(modules))

def setUp(self): # pylint:disable-msg=C0103

pyscovery.clear_modules()

def tearDown(self): # pylint:disable-msg=C0103

_test_module_count(self, 0)

pyscovery.add_module(TestModules.module)

_test_module_count(self, 1)

pyscovery.remove_module(TestModules.module)

def test_add_existing(self):

"""

pyscovery.add_module(TestModules.module)

pyscovery.add_module(TestModules.module)

_test_module_count(self, 1)

pyscovery.remove_module(TestModules.module)

def test_remove_nonexistant(self): # pylint:disable-msg=R0201

"""

Try to remove a non-existant plugin path

"""

Add multiple paths to the search paths

"""

second = '{}.1'.format(TestModules.module)

pyscovery.add_module(TestModules.module)

_test_module_count(self, 1)

pyscovery.add_module(second)

_test_module_count(self, 2)

pyscovery.remove_module(TestModules.module)

pyscovery.remove_module(second)

"""

Basic tests for the find function

"""

def test_none(self):

"""

Test that a TypeError is raised when find is called with None

"""

self.assertRaises(TypeError, pyscovery.find(None, False, False))

def test_string(self):

"""

Test that a TypeError is raised when find is called with a string

"""

self.assertRaises(TypeError, pyscovery.find('', False, False))

def test_int(self):

"""

Test that a TypeError is raised when find is called with an int

"""

self.assertRaises(TypeError, pyscovery.find(0, False, False))

def test_old_style_class(self): # pylint:disable-msg=R0201

"""

Test that a TypeError is NOT raised when find is called with an old

style class

"""

class Test: # pylint:disable-msg=R0903,W0232

""" old style class """

pass

pyscovery.find(Test, False, False)

def test_new_style_class(self): # pylint:disable-msg=R0201

"""

Test that a TypeError is NOT raised when find is called with an new

style class

"""

class Test(object): # pylint:disable-msg=R0903

""" new style class """

pass

def test_single(self):

""" Test a module with a single plugin """

_test_module(self, 'tests.modules.single', 1)

def test_multiple(self):

""" Test a module with multiple plugins """

_test_module(self, 'tests.modules.multiple', 2)

def test_mixed(self):

""" Test a module with more than just plugins """

_test_module(self, 'tests.modules.mixed', 2)

class TestPackage(unittest.TestCase): # pylint:disable-msg=R0904

""" Tests the find method of pyscovery on a package """

def setUp(self): # pylint:disable-msg=C0103

pyscovery.clear_modules()

def tearDown(self): # pylint:disable-msg=C0103

pyscovery.clear_modules()

def test_package_without_recurse(self):

""" Test a package without recursion """

_test_module(self, 'tests.modules', 0)

def test_package_recursion(self):

""" Test a package with recursion """

_test_module(self, 'tests.modules.deep', 2, recurse=True)

def test_package_deep_recursion(self):

""" Test a package with recursion """

_test_module(self, 'tests.modules', 7, recurse=True)

class TestCreate(unittest.TestCase): # pylint:disable-msg=R0904

""" Tests the find method with the create option on """

def setUp(self): # pylint:disable-msg=C0103

pyscovery.clear_modules()

def test_create_without_recurse(self):

""" Test a package with create but without recursion """

_test_module(self, 'tests.modules.deep', 1, instantiate=True)

def test_create_with_recursion(self):

""" Test a package with create and recursion """

_test_module(self, 'tests.modules.deep', 2, recurse=True,

instantiate=True)

def test_create_with_deep_recursion(self):

""" Test a packge with create and deep recursion """

_test_module(self, 'tests.modules', 7, recurse=True, instantiate=True)

class TestCreateWithParameters(unittest.TestCase): # pylint:disable-msg=R0904

""" Tests for finding and creating plugins that take arguments """

def setUp(self): # pylint:disable-msg=C0103

pyscovery.clear_modules()

pyscovery.add_module('tests.modules.create')

def test_create_args(self):

""" Tests that create works with args """

for plugin in pyscovery.find(create.ArgsPlugin, False, True,

'one', 'two'):

self.assertTupleEqual(plugin.args, ('one', 'two'))

def test_create_kwargs(self):

""" Tests that create works with kwargs """

for plugin in pyscovery.find(create.KwArgsPlugin, False, True,

one=1, two=2):

self.assertDictEqual(plugin.kwargs, {'one': 1, 'two': 2})

def test_both_args(self):

""" Tests the create works with args and kwargs """

for plugin in pyscovery.find(create.BothArgsPlugin, False, True,

'one', 'two', one=1, two=2):

self.assertTupleEqual(plugin.args, ('one', 'two'))