def test_compute_match_types_duplicate(mocker, caplog): iep = mocker.patch("raincoat.match.iter_entry_points") class MatchFactory(object): def __init__(self, name): self.name = name def __repr__(self): return self.name MatchA, MatchB = MatchFactory("A"), MatchFactory("B") entry_a, entry_b = iep.return_value = [ EntryPoint("a", "aaa"), EntryPoint("a", "bbb"), ] entry_a.load = lambda: MatchA entry_b.load = lambda: MatchB assert match_module.compute_match_types() == {"a": MatchA} assert "Several classes registered for the match type a" in caplog.records[ 0].message assert "B will be ignored" in caplog.records[0].message assert "A will be used" in caplog.records[0].message
def event_entrypoints(): """Declare some events by mocking the invenio_stats.events entrypoint. It yields a list like [{event_type: <event_type_name>}, ...]. """ data = [] result = [] for idx in range(5): event_type_name = 'event_{}'.format(idx) from pkg_resources import EntryPoint entrypoint = EntryPoint(event_type_name, event_type_name) conf = dict(event_type=event_type_name, templates='/', processor_class=EventsIndexer) entrypoint.load = lambda conf=conf: (lambda: [conf]) data.append(entrypoint) result.append(conf) # including file_download event_type_name = 'file-download' from pkg_resources import EntryPoint entrypoint = EntryPoint('invenio_files_rest', 'test_dir') conf = dict(event_type=event_type_name, templates='contrib/file-download', processor_class=EventsIndexer) entrypoint.load = lambda conf=conf: (lambda: [conf]) data.append(entrypoint) entrypoints = mock_iter_entry_points_factory(data, 'invenio_stats.events') with patch('invenio_stats.ext.iter_entry_points', entrypoints): yield result
def test_load_plugins(mocker): cli = click.Group() grp_internal = click.MultiCommand('internal') grp_external = click.MultiCommand('external') mocker.patch.object( EntryPoint, 'load', side_effect=[ lambda: grp_internal, lambda: grp_external, ], ) mocker.patch( 'connect.cli.core.plugins.pkg_resources.iter_entry_points', return_value=iter([ EntryPoint('internal', 'connect.cli.plugins.internal'), EntryPoint('external', 'external.cli.plugin'), ]), ) load_plugins(cli) assert 'internal' in cli.commands assert 'plugin' in cli.commands assert 'external' in cli.commands['plugin'].commands
def iter_entry_points(*, group): if group == "asdf.resource_mappings": yield EntryPoint( "one", "asdf.tests.test_entry_points", attrs=("resource_mappings_entry_point_one",), dist=pkg_resources.get_distribution("asdf") ) yield EntryPoint( "two", "asdf.tests.test_entry_points", attrs=("resource_mappings_entry_point_two",), dist=pkg_resources.get_distribution("asdf") )
def _mock_entry_points(group, name=None): """Return EntryPoints from different groups.""" data = { 'only_first_tasks': [EntryPoint('first_tasks', 'first_tasks')], 'only_second_tasks': [EntryPoint('second_tasks', 'second_tasks')], 'invenio_celery.tasks': [ EntryPoint('first_tasks', 'first_tasks'), EntryPoint('second_tasks', 'second_tasks'), ], } assert name is None for entry_point in data[group]: yield entry_point
def query_entrypoints(custom_permission_factory): """Same as event_entrypoints for queries.""" from pkg_resources import EntryPoint entrypoint = EntryPoint('invenio_stats', 'queries') data = [] result = [] conf = [ dict(query_name='test-query', query_class=CustomQuery, query_config=dict(index='stats-file-download', copy_fields=dict(bucket_id='bucket_id', ), required_filters=dict(bucket_id='bucket_id', )), permission_factory=custom_permission_factory), dict(query_name='test-query2', query_class=CustomQuery, query_config=dict(index='stats-file-download', copy_fields=dict(bucket_id='bucket_id', ), required_filters=dict(bucket_id='bucket_id', )), permission_factory=custom_permission_factory) ] result += conf result += register_queries() entrypoint.load = lambda conf=conf: (lambda: result) data.append(entrypoint) entrypoints = mock_iter_entry_points_factory(data, 'invenio_stats.queries') with patch('invenio_stats.ext.iter_entry_points', entrypoints): yield result
def setUp(self): self.mgr = cmds.CommandManager() self.mgr.load_namespace('contrail_api_cli.shell_command') ep = EntryPoint('cmd', 'contrail_api_cli.tests.test_command', attrs=('Cmd',)) cls = ep.load(require=False) ext = Extension('cmd', ep, cls, cls('cmd')) self.mgr.mgrs[0].extensions.append(ext)
def testDeprecationWarnings(self): ep = EntryPoint( "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"], ["x"] ) with pytest.warns(pkg_resources.PkgResourcesDeprecationWarning): ep.load(require=False)
def test_plugins(): # Declaring the plugin dist = get_distribution("FAST-OAD") dummy_plugin = EntryPoint( "test_plugin", "fastoad.module_management.tests.data.dummy_plugin", dist=dist, ) dist.get_entry_map(MODEL_PLUGIN_ID)["test_plugin"] = dummy_plugin # Before load_plugins(), services are not registered with pytest.raises(FastBundleLoaderUnknownFactoryNameError): declared_dummy_1 = RegisterDummyService.get_provider("test.plugin.declared.1") with pytest.raises(FastBundleLoaderUnknownFactoryNameError): decorated_dummy_1 = RegisterDummyService.get_provider("test.plugin.decorated.1") load_plugins() declared_dummy_1 = RegisterDummyService.get_provider("test.plugin.declared.1") assert declared_dummy_1.my_class() == "DeclaredDummy1" declared_dummy_2 = RegisterDummyService.get_provider("test.plugin.declared.2") assert declared_dummy_2.my_class() == "DeclaredDummy2" decorated_dummy_1 = RegisterDummyService.get_provider("test.plugin.decorated.1") assert decorated_dummy_1.my_class() == "DecoratedDummy1" decorated_dummy_2 = RegisterDummyService.get_provider("test.plugin.decorated.2") assert decorated_dummy_2.my_class() == "DecoratedDummy2" # This one is in a subpackage decorated_dummy_3 = RegisterDummyService.get_provider("test.plugin.decorated.3") assert decorated_dummy_3.my_class() == "DecoratedDummy3" # Checking variable description. assert Variable("dummy:variable").description == "Some dummy variable."
def container(self): container = PluginContainer('asphalt.core.test_plugin_container', BaseDummyPlugin) entrypoint = EntryPoint('dummy', 'test_util') entrypoint.load = Mock(return_value=DummyPlugin) container._entrypoints = {'dummy': entrypoint} return container
def test_get_primitives_paths_entry_points(iep_mock): # setup something_else_ep = EntryPoint('something_else', 'mlblocks.__version__') jsons_path_ep = EntryPoint('jsons_path', 'tests.test_primitives', attrs=['FAKE_MLPRIMITIVES_PATH'], dist=Distribution()) iep_mock.return_value = [something_else_ep, jsons_path_ep] # run paths = primitives.get_primitives_paths() # assert expected = ['a', 'b', 'this/is/a/fake'] assert paths == expected iep_mock.assert_called_once_with('mlprimitives')
def test_raise(self) -> None: # arrange entry = EntryPoint('Test', '__.does.not.exist', attrs=('UnknownClass', ), dist=_TEST_PLUGIN_DIST) # act & assert with self.assertRaises(ImportError): KnownImageCrawlers._load(entry)
def processor_entrypoints(): """Entrypoint fixture.""" eps = [] event_type_name = DummyProcessor.id entrypoint = EntryPoint(event_type_name, event_type_name) entrypoint.load = lambda: lambda: DummyProcessor eps.append(entrypoint) return mock_iter_entry_points_factory(eps, 'invenio_files_processor')
def register_module(self, name=None, module_name=None, attrs=(), entry_point=None): if entry_point: ep = EntryPoint.parse(entry_point) else: ep = EntryPoint(name, module_name, attrs) loaded = self._load_one_plugin(ep, invoke_on_load=True, invoke_args=(), invoke_kwds={}) if loaded: self.extensions.append(loaded) self.extensions = self.order_extensions(self.extensions) self._extensions_by_name = None
def register_module(self, name, module_name): ep = EntryPoint(name, module_name) loaded = self._load_one_plugin(ep, invoke_on_load=True, invoke_args=(), invoke_kwds={}) if loaded: self.extensions.append(loaded) self.extensions = self.order_extensions(self.extensions) self._extensions_by_name = None
def test_compute_match_types(mocker): iep = mocker.patch("raincoat.match.iter_entry_points") class MatchFactory(object): def __init__(self, name): self.name = name def __repr__(self): return self.name MatchA, MatchB = MatchFactory("A"), MatchFactory("B") entry_a, entry_b = iep.return_value = [ EntryPoint("a", "aaa"), EntryPoint("b", "bbb"), ] entry_a.load = lambda: MatchA entry_b.load = lambda: MatchB assert match_module.compute_match_types() == {"a": MatchA, "b": MatchB} assert MatchA.match_type == "a" assert MatchB.match_type == "b"
def iter_entry_points(group, name): """Mock pkg_resources.iter_entry_points to yield EntryPoint from packages found in test/data even though these are not installed. """ libpython = CubicWebConfigurationTC.datapath() prefix = 'cubicweb_' for pkgname in os.listdir(libpython): if not pkgname.startswith(prefix): continue location = join(libpython, pkgname) yield EntryPoint(pkgname[len(prefix):], pkgname, dist=Distribution(location))
def test_duplicate_queue(app): """Check that duplicate queues raise an exception.""" with app.app_context(): data = [] for idx in range(2): queue_name = 'myqueue' entrypoint = EntryPoint(queue_name, queue_name) conf = dict(name=queue_name, exchange=MOCK_MQ_EXCHANGE) entrypoint.load = lambda conf=conf: (lambda: [conf]) data.append(entrypoint) entrypoints = mock_iter_entry_points_factory(data) with patch('pkg_resources.iter_entry_points', entrypoints): with pytest.raises(DuplicateQueueError): current_queues.queues()
def template_entrypoints(): """Declare some events by mocking the invenio_stats.events entrypoint. It yields a list like [{event_type: <event_type_name>}, ...]. """ eps = [] for idx in range(5): event_type_name = 'mock_module' from pkg_resources import EntryPoint entrypoint = EntryPoint(event_type_name, event_type_name) entrypoint.load = lambda: lambda: ['mock_module.templates'] eps.append(entrypoint) entrypoints = mock_iter_entry_points_factory(eps, 'invenio_search.templates') return entrypoints
def load_all(cls): if cls.__plugins__ is not None: return cls.__plugins__ entry_points = [] # builtin plugins for _, m, _ in iter_modules(['squad/plugins']): e = EntryPoint(m, 'squad.plugins.' + m, attrs=('Plugin', )) entry_points.append(e) # external plugins plugins = iter_entry_points('squad_plugins') entry_points += list(plugins) cls.__plugins__ = {e.name: e.resolve() for e in entry_points} return cls.__plugins__
def _mock_entry_points(group, name=None): """Return EntryPoints from different groups.""" data = { 'only_first_tasks': [EntryPoint('bpackage', 'bpackage.first_tasks')], 'only_second_tasks': [EntryPoint('bpackage', 'bpackage.second_tasks')], 'bare_module_tasks': [EntryPoint('second_tasks', 'second_tasks')], 'invenio_celery.tasks': [ EntryPoint('bpackage_1', 'bpackage.first_tasks'), EntryPoint('bpackage_2', 'bpackage.second_tasks'), EntryPoint('apackage', 'apackage.third_tasks'), ], } assert name is None for entry_point in data[group]: yield entry_point
def test_queues_entrypoints(app): """Declare some queues by mocking the invenio_queues.queues entrypoint. It yields a list like [{name: queue_name, exchange: conf}, ...]. """ data = [] result = [] for idx in range(5): queue_name = 'queue{}'.format(idx) from pkg_resources import EntryPoint entrypoint = EntryPoint(queue_name, queue_name) conf = dict(name=queue_name, exchange=MOCK_MQ_EXCHANGE) entrypoint.load = lambda conf=conf: (lambda: [conf]) data.append(entrypoint) result.append(conf) entrypoints = mock_iter_entry_points_factory(data) with patch('pkg_resources.iter_entry_points', entrypoints): try: yield result finally: remove_queues(app)
def add_entry_point(group, name, module, attr): pybtex_dist = get_distribution('pybtex') entry_point = EntryPoint(name, module, (attr, ), dist=pybtex_dist) entry_point_map = pybtex_dist.get_entry_map() entry_point_map.setdefault(group, {})[name] = entry_point
def testBasics(self): ep = EntryPoint("foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"], ["x"], self.dist) self.assertfields(ep)
class TestEntryPoints: def assertfields(self, ep): assert ep.name == "foo" assert ep.module_name == "pkg_resources.tests.test_resources" assert ep.attrs == ("TestEntryPoints", ) assert ep.extras == ("x", ) assert ep.load() is TestEntryPoints expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]" assert str(ep) == expect def setup_method(self, method): self.dist = Distribution.from_filename("FooPkg-1.2-py2.4.egg", metadata=Metadata( ('requires.txt', '[x]'))) def testBasics(self): ep = EntryPoint("foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"], ["x"], self.dist) self.assertfields(ep) def testParse(self): s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]" ep = EntryPoint.parse(s, self.dist) self.assertfields(ep) ep = EntryPoint.parse("bar baz= spammity[PING]") assert ep.name == "bar baz" assert ep.module_name == "spammity" assert ep.attrs == () assert ep.extras == ("ping", ) ep = EntryPoint.parse(" fizzly = wocka:foo") assert ep.name == "fizzly" assert ep.module_name == "wocka" assert ep.attrs == ("foo", ) assert ep.extras == () # plus in the name spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer" ep = EntryPoint.parse(spec) assert ep.name == 'html+mako' reject_specs = "foo", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2" @pytest.mark.parametrize("reject_spec", reject_specs) def test_reject_spec(self, reject_spec): with pytest.raises(ValueError): EntryPoint.parse(reject_spec) def test_printable_name(self): """ Allow any printable character in the name. """ # Create a name with all printable characters; strip the whitespace. name = string.printable.strip() spec = "{name} = module:attr".format(**locals()) ep = EntryPoint.parse(spec) assert ep.name == name def checkSubMap(self, m): assert len(m) == len(self.submap_expect) for key, ep in self.submap_expect.items(): assert m.get(key).name == ep.name assert m.get(key).module_name == ep.module_name assert sorted(m.get(key).attrs) == sorted(ep.attrs) assert sorted(m.get(key).extras) == sorted(ep.extras) submap_expect = dict(feature1=EntryPoint('feature1', 'somemodule', ['somefunction']), feature2=EntryPoint('feature2', 'another.module', ['SomeClass'], ['extra1', 'extra2']), feature3=EntryPoint('feature3', 'this.module', extras=['something'])) submap_str = """ # define features for blah blah feature1 = somemodule:somefunction feature2 = another.module:SomeClass [extra1,extra2] feature3 = this.module [something] """ def testParseList(self): self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str)) with pytest.raises(ValueError): EntryPoint.parse_group("x a", "foo=bar") with pytest.raises(ValueError): EntryPoint.parse_group("x", ["foo=baz", "foo=bar"]) def testParseMap(self): m = EntryPoint.parse_map({'xyz': self.submap_str}) self.checkSubMap(m['xyz']) assert list(m.keys()) == ['xyz'] m = EntryPoint.parse_map("[xyz]\n" + self.submap_str) self.checkSubMap(m['xyz']) assert list(m.keys()) == ['xyz'] with pytest.raises(ValueError): EntryPoint.parse_map(["[xyz]", "[xyz]"]) with pytest.raises(ValueError): EntryPoint.parse_map(self.submap_str)
class TestEntryPoints: def assertfields(self, ep): assert ep.name == "foo" assert ep.module_name == "pkg_resources.tests.test_resources" assert ep.attrs == ("TestEntryPoints", ) assert ep.extras == ("x", ) assert ep.load() is TestEntryPoints expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]" assert str(ep) == expect def setup_method(self, method): self.dist = Distribution.from_filename("FooPkg-1.2-py2.4.egg", metadata=Metadata( ('requires.txt', '[x]'))) def testBasics(self): ep = EntryPoint("foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"], ["x"], self.dist) self.assertfields(ep) def testParse(self): s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]" ep = EntryPoint.parse(s, self.dist) self.assertfields(ep) ep = EntryPoint.parse("bar baz= spammity[PING]") assert ep.name == "bar baz" assert ep.module_name == "spammity" assert ep.attrs == () assert ep.extras == ("ping", ) ep = EntryPoint.parse(" fizzly = wocka:foo") assert ep.name == "fizzly" assert ep.module_name == "wocka" assert ep.attrs == ("foo", ) assert ep.extras == () # plus in the name spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer" ep = EntryPoint.parse(spec) assert ep.name == 'html+mako' def testRejects(self): for ep in [ "foo", "x=1=2", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2", ]: try: EntryPoint.parse(ep) except ValueError: pass else: raise AssertionError("Should've been bad", ep) def checkSubMap(self, m): assert len(m) == len(self.submap_expect) for key, ep in pkg_resources.iteritems(self.submap_expect): assert repr(m.get(key)) == repr(ep) submap_expect = dict(feature1=EntryPoint('feature1', 'somemodule', ['somefunction']), feature2=EntryPoint('feature2', 'another.module', ['SomeClass'], ['extra1', 'extra2']), feature3=EntryPoint('feature3', 'this.module', extras=['something'])) submap_str = """ # define features for blah blah feature1 = somemodule:somefunction feature2 = another.module:SomeClass [extra1,extra2] feature3 = this.module [something] """ def testParseList(self): self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str)) with pytest.raises(ValueError): EntryPoint.parse_group("x a", "foo=bar") with pytest.raises(ValueError): EntryPoint.parse_group("x", ["foo=baz", "foo=bar"]) def testParseMap(self): m = EntryPoint.parse_map({'xyz': self.submap_str}) self.checkSubMap(m['xyz']) assert list(m.keys()) == ['xyz'] m = EntryPoint.parse_map("[xyz]\n" + self.submap_str) self.checkSubMap(m['xyz']) assert list(m.keys()) == ['xyz'] with pytest.raises(ValueError): EntryPoint.parse_map(["[xyz]", "[xyz]"]) with pytest.raises(ValueError): EntryPoint.parse_map(self.submap_str)
class TestAddonManagerDialog(QAppTestCase): def test_widget(self): items = [ Installed( Installable("foo", "1.1", "", "", "", []), Distribution(project_name="foo", version="1.0"), ), Available(Installable("q", "1.2", "", "", "", [])), Installed(None, Distribution(project_name="a", version="0.0")), ] w = AddonManagerDialog() w.setItems(items) _ = w.items() state = w.itemState() self.assertSequenceEqual(state, []) state = [(Install, items[1])] w.setItemState(state) self.assertSequenceEqual(state, w.itemState()) state = state + [(Upgrade, items[0])] w.setItemState(state) self.assertSequenceEqual(state, w.itemState()[::-1]) state = [(Uninstall, items[0])] w.setItemState(state) self.assertSequenceEqual(state, w.itemState()) updateTopLayout = w._AddonManagerDialog__updateTopLayout updateTopLayout(False) updateTopLayout(True) @patch("orangecanvas.config.default.addon_entry_points", return_value=[ EntryPoint("a", "b", dist=Distribution(project_name="foo", version="1.0")) ]) def test_drop(self, p1): items = [ Installed( Installable("foo", "1.1", "", "", "", []), Distribution(project_name="foo", version="1.0"), ), ] w = AddonManagerDialog() w.setItems(items) # drop an addon already in the list pkginfo = "Metadata-Version: 1.0\nName: foo\nVersion: 0.9" with addon_archive(pkginfo) as fn: event = self._drop_event(QUrl.fromLocalFile(fn)) w.dropEvent(event) items = w.items() self.assertEqual(1, len(items)) self.assertEqual("0.9", items[0].installable.version) self.assertEqual(True, items[0].installable.force) state = [(Upgrade, items[0])] self.assertSequenceEqual(state, w.itemState()) # drop a new addon pkginfo = "Metadata-Version: 1.0\nName: foo2\nVersion: 0.8" with addon_archive(pkginfo) as fn: event = self._drop_event(QUrl.fromLocalFile(fn)) w.dropEvent(event) items = w.items() self.assertEqual(2, len(items)) self.assertEqual("0.8", items[1].installable.version) self.assertEqual(True, items[1].installable.force) state = state + [(Install, items[1])] self.assertSequenceEqual(state, w.itemState()) def _drop_event(self, url): # make sure data does not get garbage collected before it used # pylint: disable=attribute-defined-outside-init self.event_data = data = QMimeData() data.setUrls([QUrl(url)]) return QDropEvent(QPoint(0, 0), Qt.MoveAction, data, Qt.NoButton, Qt.NoModifier, QDropEvent.Drop) def test_run_query(self): w = AddonManagerDialog() query_res = [ addons._QueryResult("uber-pkg", None), addons._QueryResult( "unter-pkg", Installable("unter-pkg", "0.0.0", "", "", "", [])) ] def query(names): return query_res with patch.object(QMessageBox, "exec_", return_value=QMessageBox.Cancel), \ patch.object(addons, "query_pypi", query): f = w.runQueryAndAddResults(["uber-pkg", "unter-pkg"], ) loop = QEventLoop() f.add_done_callback(qinvoke(lambda f: loop.quit(), loop)) loop.exec() items = w.items() self.assertEqual(items, [Available(query_res[1].installable)]) def test_install(self): w = AddonManagerDialog() foo = Available(Installable("foo", "1.1", "", "", "", [])) w.setItems([foo]) w.setItemState([(Install, foo)]) with patch.object(addons.PipInstaller, "install", lambda self, pkg: None), \ patch.object(QMessageBox, "exec_", return_value=QMessageBox.Cancel): b = w.findChild(QDialogButtonBox) b.accepted.emit() QTest.qWait(1) w.reject() QTest.qWait(1) w.deleteLater()