def test_deprecated_module_configure_injection(): class Test(Module): @inject def configure(self, binder, name: int): pass class Test2(Module): @inject def __init__(self, name: int): pass @inject def configure(binder, name: int): pass for module in [Test, Test2, configure, Test()]: with warnings.catch_warnings(record=True) as w: print(module) Injector(module) assert len(w) == 1, w
def test_class_assisted_builder_of_partially_injected_class(): class A(object): pass class B(object): @inject(a=A, b=str) def __init__(self, a, b): self.a = a self.b = b class C(object): @inject(a=A, builder=ClassAssistedBuilder[B]) def __init__(self, a, builder): self.a = a self.b = builder.build(b='C') c = Injector().get(C) assert isinstance(c, C) assert isinstance(c.b, B) assert isinstance(c.b.a, A)
def test_dataclass_integration_works(): import dataclasses # Python 3.6+-only syntax below exec( """ @inject @dataclasses.dataclass class Data: name: str """, locals(), globals(), ) def configure(binder): binder.bind(str, to='data') injector = Injector([configure]) assert injector.get(Data).name == 'data'
def test_child_injector_rebinds_arguments_for_parent_scope(): class Cls: val = "" class A(Cls): @inject def __init__(self, val: str): self.val = val def configure_parent(binder): binder.bind(Cls, to=A) binder.bind(str, to="Parent") def configure_child(binder): binder.bind(str, to="Child") parent = Injector(configure_parent) assert parent.get(Cls).val == "Parent" child = parent.create_child_injector(configure_child) assert child.get(Cls).val == "Child"
def test_more_useful_exception_is_raised_when_parameters_type_is_any(): @inject def fun(a: Any) -> None: pass injector = Injector() # This was the exception before: # # TypeError: Cannot instantiate <class 'typing.AnyMeta'> # # Now: # # injector.CallError: Call to AnyMeta.__new__() failed: Cannot instantiate # <class 'typing.AnyMeta'> (injection stack: ['injector_test_py3']) # # In this case the injection stack doesn't provide too much information but # it quickly gets helpful when the stack gets deeper. with pytest.raises((CallError, TypeError)): injector.call_with_injection(fun)
def test_child_scope(): TestKey = Key('TestKey') TestKey2 = Key('TestKey2') def parent_module(binder): binder.bind(TestKey, to=object, scope=singleton) def first_child_module(binder): binder.bind(TestKey2, to=object, scope=singleton) def second_child_module(binder): binder.bind(TestKey2, to='marker', scope=singleton) injector = Injector(modules=[parent_module]) first_child_injector = injector.create_child_injector(modules=[first_child_module]) second_child_injector = injector.create_child_injector(modules=[second_child_module]) assert first_child_injector.get(TestKey) is first_child_injector.get(TestKey) assert first_child_injector.get(TestKey) is second_child_injector.get(TestKey) assert first_child_injector.get(TestKey2) is not second_child_injector.get(TestKey2)
def setup(self): class A(object): counter = 0 def __init__(self): A.counter += 1 @inject(a=A) class B(object): pass @inject(a=A) class C(object): def __init__(self, noninjectable): self.noninjectable = noninjectable self.injector = Injector() self.A = A self.B = B self.C = C
def test_class_assisted_builder_of_partially_injected_class(): class A: pass class B: @inject def __init__(self, a: A, b: str): self.a = a self.b = b class C: @inject def __init__(self, a: A, builder: ClassAssistedBuilder[B]): self.a = a self.b = builder.build(b='C') c = Injector().get(C) assert isinstance(c, C) assert isinstance(c.b, B) assert isinstance(c.b.a, A)
def get_polygon(self, arg_string): """Get class using reflection and Dependency Injection with API Injector""" self.parser.set_string(arg_string) arguments = self.parser.argument_parser().get_arguments() # instead of abstract fabric have used reflection and assential injection TypePolygon = getattr(importlib.import_module("models.type_polygons"), arguments[0]) InjectedPolygon = BoundKey(TypePolygon, x=InstanceProvider(arguments[1]), y=InstanceProvider(arguments[2]), side=InstanceProvider(arguments[3]), n=InstanceProvider(arguments[4])) injector = Injector() polygon = injector.get(InjectedPolygon) self.notify_observer(polygon) return polygon
def test_child_scope(): TestKey = NewType('TestKey', str) TestKey2 = NewType('TestKey2', str) def parent_module(binder): binder.bind(TestKey, to='in parent', scope=singleton) def first_child_module(binder): binder.bind(TestKey2, to='in first child', scope=singleton) def second_child_module(binder): binder.bind(TestKey2, to='in second child', scope=singleton) injector = Injector(modules=[parent_module]) first_child_injector = injector.create_child_injector(modules=[first_child_module]) second_child_injector = injector.create_child_injector(modules=[second_child_module]) assert first_child_injector.get(TestKey) is first_child_injector.get(TestKey) assert first_child_injector.get(TestKey) is second_child_injector.get(TestKey) assert first_child_injector.get(TestKey2) is not second_child_injector.get(TestKey2)
async def main(): port = 56153 base = URL("http://localhost").with_port(port) config = Config.withOverrides({ Setting.DRIVE_AUTHORIZE_URL: str(base.with_path("o/oauth2/v2/auth")), Setting.AUTHENTICATE_URL: str(base.with_path("drive/authorize")), Setting.DRIVE_TOKEN_URL: str(base.with_path("token")), Setting.DRIVE_REFRESH_URL: str(base.with_path("oauth2/v4/token")), Setting.INGRESS_PORT: 56152 }) injector = Injector(SimServerModule(config)) server = injector.get(SimulationServer) # start the server runner = aiohttp.web.AppRunner(server.createApp()) await runner.setup() site = aiohttp.web.TCPSite(runner, "0.0.0.0", port=port) await site.start() print("Server started on port " + str(port)) print("Open a browser at http://localhost:" + str(port))
def test_child_injector_rebinds_arguments_for_parent_scope(): I = Key("interface") Cls = Key("test_class") class A: @inject def __init__(self, val: I): self.val = val def configure_parent(binder): binder.bind(Cls, to=A) binder.bind(I, to="Parent") def configure_child(binder): binder.bind(I, to="Child") parent = Injector(configure_parent) assert (parent.get(Cls).val == "Parent") child = parent.create_child_injector(configure_child) assert (child.get(Cls).val == "Child")
def test_that_injection_is_lazy(): class Interface: constructed = False def __init__(self): Interface.constructed = True class A: @inject def __init__(self, i: Interface): self.i = i def configure(binder): binder.bind(Interface) binder.bind(A) injector = Injector(configure) assert not (Interface.constructed) injector.get(A) assert (Interface.constructed)
def create_app(test_config=None): app = Flask(__name__, instance_relative_config=True) app.config.from_mapping( SECRET_KEY='dev' ) app.config['MYSQL_HOST'] = os.environ.get('DB_HOST') app.config['MYSQL_USER'] = os.environ.get('DB_USER') app.config['MYSQL_PASSWORD'] = os.environ.get('DB_PASSWORD') app.config['MYSQL_DB'] = os.environ.get('DB_DATABASE') app.config['MYSQL_CURSORCLASS'] = 'DictCursor' if test_config is None: app.config.from_pyfile('config.py', silent=True) else: app.config.from_mapping(test_config) try: os.makedirs(app.instance_path) except OSError: pass from . import course from . import event from . import player app.register_blueprint(course.bp) app.register_blueprint(event.bp) app.register_blueprint(player.bp) from scores.repo.eventrepo import EventRepo @inject @app.route('/') def home(repo: EventRepo): return event.events(repo) from .servicemodule import ServiceModule injector = Injector([ServiceModule(app)]) FlaskInjector(app=app, injector=injector) return app
def init_app(config): app = flask.Flask(__name__) app.config.from_object(config) app.json_encoder = FlaskCustomJSONEncoder db.init_app(app) if not app.testing: logging.basicConfig(level=logging.INFO) app.register_blueprint(blueprint=blueprint, url_prefix='/') # Sentry - only for production # Todo uncomment this if you have a sentry DSN # if not app.debug and not app.testing and 'SENTRY_DSN' in app.config: # from raven.contrib.flask import Sentry # Sentry(app) @app.errorhandler(ClientException) def handle_client_errors(error): response = flask.jsonify(error.to_dict()) response.status_code = error.status_code return response with app.app_context(): db.create_all() my_injector = Injector([ ServiceModule, FactoryModule, PersonRepositoryModule ]) FlaskInjector(app=app, injector=my_injector) # No configuration after injection return app
def test_cyclic_dependencies(): class Interface: pass class A: @inject def __init__(self, i: Interface): self.i = i class B: @inject def __init__(self, a: A): self.a = a def configure(binder): binder.bind(Interface, to=B) binder.bind(A) injector = Injector(configure) with pytest.raises(CircularDependency): injector.get(A)
def main(): db_path = os.path.join( os.path.dirname(os.path.realpath(__file__)) + os.sep + 'app.db') app = Flask(__name__) app.secret_key = os.getenv('SECRET_KEY', 'b3D$EJAQ4g91U8UPqwZ4yaaSoAsH!V') app.register_blueprint(main_blueprint, url_prefix='/') app.register_blueprint(config_blueprint, url_prefix='/config') app.register_blueprint(config_account_blueprint, url_prefix='/config/account') app.register_blueprint(config_plan_blueprint, url_prefix='/config/plan') app.register_blueprint(config_settings_blueprint, url_prefix='/config/settings') app.config.update(SQLALCHEMY_DATABASE_URI='sqlite:///{0}'.format(db_path), SQLALCHEMY_TRACK_MODIFICATIONS=False) app.debug = os.getenv('DEBUGGING', 'N') == 'Y' injector = Injector([AppModule(app)]) FlaskInjector(app=app, injector=injector) app.run()
def test_cyclic_dependencies(): class Interface(object): pass class A(object): @inject(i=Interface) def __init__(self, i): self.i = i class B(object): @inject(a=A) def __init__(self, a): self.a = a def configure(binder): binder.bind(Interface, to=B) binder.bind(A) injector = Injector(configure) with pytest.raises(CircularDependency): injector.get(A)
async def injector(cleandir, server_url, ports): drive_creds = Creds(FakeTime(), "test_client_id", None, "test_access_token", "test_refresh_token") with open(os.path.join(cleandir, "secrets.yaml"), "w") as f: f.write("for_unit_tests: \"password value\"\n") with open(os.path.join(cleandir, "credentials.dat"), "w") as f: f.write(json.dumps(drive_creds.serialize())) config = Config.withOverrides({ Setting.DRIVE_URL: server_url, Setting.HASSIO_URL: server_url + "/", Setting.HOME_ASSISTANT_URL: server_url + "/core/api/", Setting.AUTHENTICATE_URL: server_url + "/drive/authorize", Setting.DRIVE_REFRESH_URL: server_url + "/oauth2/v4/token", Setting.DRIVE_AUTHORIZE_URL: server_url + "/o/oauth2/v2/auth", Setting.DRIVE_TOKEN_URL: server_url + "/token", Setting.REFRESH_URL: server_url + "/drive/refresh", Setting.ERROR_REPORT_URL: server_url + "/logerror", Setting.HASSIO_TOKEN: "test_header", Setting.SECRETS_FILE_PATH: "secrets.yaml", Setting.CREDENTIALS_FILE_PATH: "credentials.dat", Setting.FOLDER_FILE_PATH: "folder.dat", Setting.RETAINED_FILE_PATH: "retained.json", Setting.ID_FILE_PATH: "id.json", Setting.STOP_ADDON_STATE_PATH: "stop_addon.json", Setting.INGRESS_TOKEN_FILE_PATH: "ingress.dat", Setting.DEFAULT_DRIVE_CLIENT_ID: "test_client_id", Setting.DEFAULT_DRIVE_CLIENT_SECRET: "test_client_secret", Setting.BACKUP_DIRECTORY_PATH: cleandir, Setting.PORT: ports.ui, Setting.INGRESS_PORT: ports.ingress }) # PROBLEM: Something in uploading snapshot chunks hangs between the client and server, so his keeps tests from # taking waaaaaaaay too long. Remove this line and the @pytest.mark.flaky annotations once the problem is identified. config.override(Setting.GOOGLE_DRIVE_TIMEOUT_SECONDS, 5) # logging.getLogger('injector').setLevel(logging.DEBUG) return Injector([BaseModule(config), TestModule(ports)])
def main(argv: Any): """Stuff to setup after absl is run.""" setup_logging(FLAGS.logtype) try: modules = modules_func() modules.insert(0, EnvironmentModule) modules.insert(0, DecoratorProcessorModule) modules.insert(0, SignalHandlerModule) modules.insert(0, ExecuteModule) modules.insert(0, MetriczPageModule) injector = Injector(modules=modules, auto_bind=False) env = injector.get(Environment) log.info(f'Application running with environment {env.name}') bindings = get_bindings(injector) for binding in bindings: try: log.debug(f'Resolving binding for {binding}') injector.get(binding) except: log.exception( f'Could not start application: Error resolving binding {binding}') return 1 # Run all decorator processors. decorator_processor_runner = injector.get(DecoratorProcessorRunner) decorator_processor_runner.run_processors() # Run all execute methods and wait until all finished. execute_processor = injector.get(ExecuteProcessor) execute_processor.run_and_wait() log.info('Application finished successfully') return 0 except: log.exception('Application finished with an error') return 1
def test_providerof(): counter = [0] def provide_str(): counter[0] += 1 return 'content' def configure(binder): binder.bind(str, to=provide_str) injector = Injector(configure) assert counter[0] == 0 provider = injector.get(ProviderOf[str]) assert counter[0] == 0 assert provider.get() == 'content' assert counter[0] == 1 assert provider.get() == injector.get(str) assert counter[0] == 3
def test_injecting_undecorated_class_with_missing_dependencies_raises_the_right_error(): class A(object): def __init__(self, parameter): pass class B(object): @inject(a=A) def __init__(self, a): pass injector = Injector() try: injector.get(B) except CallError as ce: function = A.__init__ # Python 3 compatibility try: function = function.__func__ except AttributeError: pass assert (ce.args[1] == function)
class TestTempSource(TestCase): injector = Injector([configure_test]) factory = injector.get(ProbeTempSourceFactory) def test_nickname(self): source = self.factory.get_temp_source("room") self.assertEqual(source.get_name(), tempSource.PROBE_PREFIX + "room") source.set_nickname("nick") self.assertEqual(source.get_display_name(), "nick") def test_filename(self): api = self.injector.get(ProbeApi) source2 = tempSource.TempSource(api, "path/to/a/filename2") self.assertEqual(source2.get_display_name(), tempSource.PROBE_PREFIX + "a") source3 = tempSource.TempSource( api, "/sys/bus/w1/devices/uniquename/w1_slave") self.assertEqual(source3.get_display_name(), tempSource.PROBE_PREFIX + "uniquename") source4 = tempSource.TempSource( api, "sys/bus/w1/devices/28-041651652cff/w1_slave") self.assertEqual(source4.get_display_name(), tempSource.PROBE_PREFIX + "28-041651652cff") def test_equality(self): api = self.injector.get(ProbeApi) source1 = tempSource.TempSource(api, "path/to/a/filename2") source2 = tempSource.TempSource(api, "path/to/a/filename2") source1.set_primary(True) self.assertEqual(source1, source2) def test_temp(self): api = self.injector.get(ProbeApi) source1 = tempSource.TempSource(api, "brew") self.assertEqual( type(source1.get_temperature_measurement().measurement_amt), float)
def main(): global agents # This file is set up to use different models and datasets. dataset = 'offensive' model_type = 'nb' assert dataset in datasets assert model_type in models train_size = datasets[dataset]['train_size'] test_size = datasets[dataset]['test_size'] if train_size is None: init_train_data_portion = 0.08 else: init_train_data_portion = 100 / train_size # No caller (assume free to call). agents = agents[:-1] # Set up the data, model, and incentive mechanism. inj = Injector([ DefaultCollaborativeTrainerModule, datasets[dataset]['module'], MurmurHash3Module, LoggingModule, models[model_type]['module'], StakeableImModule, ]) s = inj.get(Simulator) # Start the simulation. s.simulate( agents, baseline_accuracy=models[model_type]['baseline_accuracy'].get(dataset), init_train_data_portion=init_train_data_portion, train_size=train_size, test_size=test_size, filename_indicator=f"{dataset}-{model_type}")
def assist(): app = Flask(__name__) module = AppModule() injector = Injector([module]) assist = Assistant(app, project_id="test-project-id", injector=injector) @assist.action("simple_intent") def simple_intent(): speech = "Yes" return ask(speech) @inject @assist.action("simple_intent_with_inject") def simple_intent_with_inject(speech: str): return ask(speech) @inject @assist.action("simple_intent_with_inject_and_param") def simple_intent_with_inject_and_param(speech: str, param): return ask(param + "." + speech) @inject @assist.action("intent_with_injects_and_2_param") def intent_with_injects_and_2_param(speech: str, p1, p2, i: int): return ask(speech + ":" + p1 + ":" + p2 + ":" + str(i)) @assist.action("add_context_1") def add_context(): speech = "Adding context to context_out" manager.add("context_1") return ask(speech) @assist.context("context_1") @assist.action("intent_with_context_injects_params") @inject def intent_with_context_injects_params(speech: str, p1, p2, i: int): return ask("context_1:" + speech + ":" + p1 + ":" + p2 + ":" + str(i)) return assist
def setUp(self): def configure(binder): PROVIDER = "sqlite" FILE_NAME = os.path.join("..", "..", "data", "database-test.sqlite") create_db = True args = { "provider": PROVIDER, "filename": FILE_NAME, "create_db": create_db } db = Database(**args) db.model.generate_mapping(create_tables=True) binder.bind(Database, to=db, scope=singleton) for service in SERVICES: binder.bind(service, scope=singleton) self.injector = Injector(modules=[configure]) self.db = self.injector.get(Database)
def test_forward_references_in_annotations_are_handled(): # See https://www.python.org/dev/peps/pep-0484/#forward-references for details def configure(binder): binder.bind(X, to=X('hello')) @inject def fun(s: 'X') -> 'X': return s # The class needs to be module-global in order for the string -> object # resolution mechanism to work. I could make it work with locals but it # doesn't seem worth it. global X class X: def __init__(self, message: str) -> None: self.message = message try: injector = Injector(configure) injector.call_with_injection(fun).message == 'hello' finally: del X
def main(): def configure(binder): binder.bind(CustomerService, to=CustomerService()) binder.bind(OrderService, to=OrderService()) try: injector = Injector([configure]) controller = injector.get(CRMSystemServiceController) if controller is None: raise Exception("Invalid Controller Impl Specified") customers, orders = controller.process() print(TableGenerator.get_customer_table(customers)) print('\n') print(TableGenerator.get_orders_table(orders)) except CRMSystemError as error: print('Application Error Occurred ... {0}'.format(error.__str__())) except Exception as error: print('General Error Occurred!') except: print('Unknown Error Occurred!')
def test_injection_works_in_presence_of_return_value_annotation(): # Code with PEP 484-compatible type hints will have __init__ methods # annotated as returning None[1] and this didn't work well with Injector. # # [1] https://www.python.org/dev/peps/pep-0484/#the-meaning-of-annotations class A: def __init__(self, s: str) -> None: self.s = s def configure(binder): binder.bind(str, to='this is string') injector = Injector([configure], use_annotations=True) # Used to fail with: # injector.UnknownProvider: couldn't determine provider for None to None a = injector.get(A) # Just a sanity check, if the code above worked we're almost certain # we're good but just in case the return value annotation handling changed # something: assert a.s == 'this is string'
def test_special_interfaces_work_with_auto_bind_disabled(): class InjectMe: pass def configure(binder): binder.bind(InjectMe, to=InstanceProvider(InjectMe())) injector = Injector(configure, auto_bind=False) # This line used to fail with: # Traceback (most recent call last): # File "/projects/injector/injector_test.py", line 1171, # in test_auto_bind_disabled_regressions # injector.get(ProviderOf(InjectMe)) # File "/projects/injector/injector.py", line 687, in get # binding = self.binder.get_binding(None, key) # File "/projects/injector/injector.py", line 459, in get_binding # raise UnsatisfiedRequirement(cls, key) # UnsatisfiedRequirement: unsatisfied requirement on # <injector.ProviderOf object at 0x10ff01550> injector.get(ProviderOf[InjectMe]) # This used to fail with an error similar to the ProviderOf one injector.get(ClassAssistedBuilder[InjectMe])