def test_from_dict(self): test_dict = self.config.to_dict(private=True, protected=True) # Make sure that the legacy async key works test_dict.pop("asynchronous") test_dict["async"] = False # Make actual call type_instance = ConfigurationType.from_dict(test_dict, MOCK_CONFIGURATION) self.assertEqual(type_instance.test, "public") self.assertEqual(type_instance.test2, "protected") self.assertEqual(type_instance.test3, "private") self.assertEqual(type_instance.test4, "variable") self.assertEqual(type_instance.asynchronous, False) self.assertEqual(type_instance.global_configuration, "global configuration") self.assertEqual(type_instance.namespace_configuration, "namespace configuration") self.assertEqual(type_instance._private, self.config._private) # Call with malformed dicts try: ConfigurationType.from_dict({"_namespace": "test"}, MOCK_CONFIGURATION) self.fail( "from_dict does not fail if _private is missing from configuration." ) except AssertionError: pass try: ConfigurationType.from_dict({"_private": "test"}, MOCK_CONFIGURATION) self.fail( "from_dict does not fail if _namespace is missing from configuration." ) except AssertionError: pass
class TestRunSerieTask(TestCase): fixtures = ["test-shell-resource-mock"] def setUp(self): super().setUp() self.config = ConfigurationType( namespace="shell_resource", private=["_resource", "_continuation_limit"], ) self.config.update({ "resource": "resources.ShellResourceMock", }) self.args_list = [["test"], ["success"], ["fail"]] self.kwargs_list = [{"context": 5} for _ in range(len(self.args_list))] def check_results(self, results, expected_length): self.assertEqual(len(results), expected_length) for pk in results: self.assertIsInstance(pk, int) self.assertGreater(pk, 0) @patch("datagrowth.resources.shell.tasks.run", wraps=run) def test_run_serie(self, run_mock): scc, err = run_serie(self.args_list, self.kwargs_list, config=self.config) self.check_results(scc, 2) self.check_results(err, 1) run_mock.assert_has_calls([ call("test", context=5, config=self.config), call("success", context=5, config=self.config), call("fail", context=5, config=self.config) ])
def test_from_dict(self): # Call with correct dict type_instance = ConfigurationType.from_dict( self.config.to_dict(private=True, protected=True), MOCK_CONFIGURATION) self.assertEqual(type_instance.test, "public") self.assertEqual(type_instance.test2, "protected") self.assertEqual(type_instance.test3, "private") self.assertEqual(type_instance.test4, "variable") self.assertEqual(type_instance.global_configuration, "global configuration") self.assertEqual(type_instance.namespace_configuration, "namespace configuration") self.assertEqual(type_instance._private, self.config._private) # Call with malformed dicts try: ConfigurationType.from_dict({"_namespace": "test"}, MOCK_CONFIGURATION) self.fail( "from_dict does not fail if _private is missing from configuration." ) except AssertionError: pass try: ConfigurationType.from_dict({"_private": "test"}, MOCK_CONFIGURATION) self.fail( "from_dict does not fail if _namespace is missing from configuration." ) except AssertionError: pass
def test_init(self): # Implicit init without defaults # Notice that apps can manipulate the DATAGROWTH_DEFAULT_CONFIGURATION upon app.ready # Therefor defaults are not loaded until first access instance = ConfigurationType() self.assertEqual(instance._defaults, None) self.assertEqual(instance._namespace, ConfigurationType._global_prefix) self.assertEqual(instance._private, ConfigurationType._private_defaults) purge_immediately = instance.purge_immediately # this loads the defaults self.assertFalse(purge_immediately) self.assertEqual(instance._defaults, DATAGROWTH_DEFAULT_CONFIGURATION) # Implicit init with defaults instance = ConfigurationType(defaults=MOCK_CONFIGURATION) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) self.assertEqual(instance._namespace, ConfigurationType._global_prefix) self.assertEqual(instance._private, ConfigurationType._private_defaults) purge_immediately = instance.purge_immediately # this won't load defaults as defaults got set self.assertFalse(purge_immediately) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) # Explicit init with double private key instance = ConfigurationType(namespace="name", private=["_test", "_test", "oops"], defaults=MOCK_CONFIGURATION) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) self.assertEqual(instance._namespace, "name") self.assertEqual( instance._private, ConfigurationType._private_defaults + ["_test", "_oops"])
def setUp(self): super().setUp() self.config = ConfigurationType( namespace="shell_resource", private=["_resource", "_continuation_limit"], ) self.config.update({ "resource": "resources.ShellResourceMock", })
def setUp(self): super().setUp() self.config = ConfigurationType( namespace="http_resource", private=["_resource", "_continuation_limit"], ) self.config.update({ "resource": "resources.HttpResourceMock", }) self.session = MockRequests
def setUp(self): super().setUp() self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private" })
def setUp(self): super().setUp() self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private", "$test4": "variable" # variable config is not recommended })
def setUp(self): super().setUp() self.config = ConfigurationType( namespace="shell_resource", private=["_resource", "_continuation_limit"], ) self.config.update({ "resource": "resources.ShellResourceMock", }) self.args_list = [["test"], ["success"], ["fail"]] self.kwargs_list = [{"context": 5} for _ in range(len(self.args_list))]
class TestLoadConfigDecorator(TestCase): def setUp(self): self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private" }) @staticmethod @load_config(defaults=MOCK_CONFIGURATION) def decorated(config, *args, **kwargs): return config, args, kwargs def test_decorator(self): # Standard call test_config, test_args, test_kwargs = self.decorated( "test", test="test", config=self.config.to_dict(protected=True, private=True) ) self.assertIsInstance(test_config, ConfigurationType) self.assertEqual(test_config._defaults, MOCK_CONFIGURATION) self.assertEqual(test_config._namespace, "name") self.assertIn("_test3", test_config._private) self.assertEqual(self.config.test, "public") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.assertEqual(self.config._test2, "protected") self.assertEqual(self.config._test3, "private") self.assertEqual(test_args, ("test",)) self.assertEqual(test_kwargs, {"test": "test"}) # Call with config set to a ConfigurationType test_config, test_args, test_kwargs = self.decorated( "test", test="test", config=self.config ) self.assertEqual(test_config, self.config) self.assertEqual(test_args, ("test",)) self.assertEqual(test_kwargs, {"test": "test"}) # Wrong invocation try: test_config, test_args, test_kwargs = self.decorated( "test", test="test", ) self.fail("load_config did not throw an exception when no config kwarg was set.") except TypeError: pass
class TestLoadConfigDecorator(TestCase): def setUp(self): super().setUp() self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private" }) @staticmethod @load_config(defaults=MOCK_CONFIGURATION) def decorated(config, *args, **kwargs): return config, args, kwargs def test_decorator(self): # Standard call test_config, test_args, test_kwargs = self.decorated( "test", test="test", config=self.config.to_dict(protected=True, private=True)) self.assertIsInstance(test_config, ConfigurationType) self.assertEqual(test_config._defaults, MOCK_CONFIGURATION) self.assertEqual(test_config._namespace, "name") self.assertIn("_test3", test_config._private) self.assertEqual(self.config.test, "public") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.assertEqual(self.config._test2, "protected") self.assertEqual(self.config._test3, "private") self.assertEqual(test_args, ("test", )) self.assertEqual(test_kwargs, {"test": "test"}) # Call with config set to a ConfigurationType test_config, test_args, test_kwargs = self.decorated( "test", test="test", config=self.config) self.assertEqual(test_config, self.config) self.assertEqual(test_args, ("test", )) self.assertEqual(test_kwargs, {"test": "test"}) # Wrong invocation try: test_config, test_args, test_kwargs = self.decorated( "test", test="test", ) self.fail( "load_config did not throw an exception when no config kwarg was set." ) except TypeError: pass
class TestGetStandardizedConfiguration(TestCase): def setUp(self): self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private" }) def test_standardized_configuration(self): out = get_standardized_configuration(self.config) self.assertEqual(out, "3601ce2b866f9ccff5e9e49b628e65108abb3d5ada72fce6511645212c0ce520") out = get_standardized_configuration(self.config, as_hash=False) self.assertEqual(out, "test=public")
def setUp(self): super().setUp() self.empty = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private", "$test4": "variable", # variable config is not recommended "async": False # should map to "asynchronous" property for Python 3.7+ })
def setUp(self): self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private" })
def setUp(self): self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private", "$test4": "variable" # variable config is not recommended })
class TestGetStandardizedConfiguration(TestCase): def setUp(self): super().setUp() self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private" }) def test_standardized_configuration(self): out = get_standardized_configuration(self.config) self.assertEqual( out, "3601ce2b866f9ccff5e9e49b628e65108abb3d5ada72fce6511645212c0ce520") out = get_standardized_configuration(self.config, as_hash=False) self.assertEqual(out, "test=public")
class TestHTTPTasksBase(TestCase): fixtures = ["test-http-resource-mock"] method = "" def setUp(self): super().setUp() self.config = ConfigurationType( namespace="http_resource", private=["_resource", "_continuation_limit"], ) self.config.update({ "resource": "resources.HttpResourceMock", }) self.session = MockRequests def get_args_list(self, queries): if self.method == "get": return [[query] for query in queries] elif self.method == "post": return [[] for query in queries] else: raise Exception("{} does not have a valid method specified.".format(self.__class__.__name__)) def get_kwargs_list(self, queries): if self.method == "get": return [{} for query in queries] elif self.method == "post": return [{"query": query} for query in queries] else: raise Exception("{} does not have a valid method specified.".format(self.__class__.__name__)) def check_results(self, results, expected_length): self.assertEqual(len(results), expected_length) for pk in results: self.assertIsInstance(pk, int) self.assertGreater(pk, 0)
class TestRunTask(TestCase): fixtures = ["test-shell-resource-mock"] def setUp(self): super().setUp() self.config = ConfigurationType( namespace="shell_resource", private=["_resource", "_continuation_limit"], ) self.config.update({ "resource": "resources.ShellResourceMock", }) def check_results(self, results, expected_length): self.assertEqual(len(results), expected_length) for pk in results: self.assertIsInstance(pk, int) self.assertGreater(pk, 0) def test_run(self): scc, err = run("test", context=5, config=self.config) self.check_results(scc, 1) self.check_results(err, 0) # Similar but with a cached result scc, err = run("success", context=5, config=self.config) self.check_results(scc, 1) self.check_results(err, 0) # And with an error result scc, err = run("fail", context=5, config=self.config) self.check_results(scc, 0) self.check_results(err, 1) # In total there should be three Resources (two old, one new) self.assertEqual( ShellResourceMock.objects.count(), 3, "Expected three ShellResourceMock instances. Two from cache and one new" )
def test_from_dict(self): # Call with correct dict type_instance = ConfigurationType.from_dict( self.config.to_dict(private=True, protected=True), MOCK_CONFIGURATION ) self.assertEqual(type_instance.test, "public") self.assertEqual(type_instance.test2, "protected") self.assertEqual(type_instance.test3, "private") self.assertEqual(type_instance.test4, "variable") self.assertEqual(type_instance.global_configuration, "global configuration") self.assertEqual(type_instance.namespace_configuration, "namespace configuration") self.assertEqual(type_instance._private, self.config._private) # Call with malformed dicts try: ConfigurationType.from_dict({"_namespace": "test"}, MOCK_CONFIGURATION) self.fail("from_dict does not fail if _private is missing from configuration.") except AssertionError: pass try: ConfigurationType.from_dict({"_private": "test"}, MOCK_CONFIGURATION) self.fail("from_dict does not fail if _namespace is missing from configuration.") except AssertionError: pass
def setUp(self): super().setUp() self.config = ConfigurationType(namespace="test",)
class TestConfigurationType(TestCase): def setUp(self): self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private", "$test4": "variable" # variable config is not recommended }) def test_init(self): # Implicit init without defaults # Notice that apps can manipulate the DEFAULT_CONFIGURATION upon app.ready # Therefor defaults are not loaded until first access instance = ConfigurationType() self.assertEqual(instance._defaults, None) self.assertEqual(instance._namespace, ConfigurationType._global_prefix) self.assertEqual(instance._private, ConfigurationType._private_defaults) purge_immediately = instance.purge_immediately # this loads the defaults self.assertFalse(purge_immediately) self.assertEqual(instance._defaults, DEFAULT_CONFIGURATION) # Implicit init with defaults instance = ConfigurationType(defaults=MOCK_CONFIGURATION) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) self.assertEqual(instance._namespace, ConfigurationType._global_prefix) self.assertEqual(instance._private, ConfigurationType._private_defaults) purge_immediately = instance.purge_immediately # this won't load defaults as defaults got set self.assertFalse(purge_immediately) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) # Explicit init with double private key instance = ConfigurationType(namespace="name", private=["_test", "_test", "oops"], defaults=MOCK_CONFIGURATION) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) self.assertEqual(instance._namespace, "name") self.assertEqual(instance._private, ConfigurationType._private_defaults + ["_test", "_oops"]) def test_attribute_access(self): self.assertEqual(self.config.test, "public") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.assertEqual(self.config._test2, "protected") self.assertEqual(self.config._test3, "private") self.assertEqual(self.config.test4, "variable") # Not found error try: self.test = self.config.test5 self.fail("ConfigurationType should raise an exception when configuration is not available") except ConfigurationNotFoundError: pass # Namespace configuration self.assertNotIn("namespace_configuration", self.config.__dict__) self.assertEqual(self.config.namespace_configuration, "namespace configuration") try: self.test = self.config.namespace_missing self.fail("ConfigurationType should raise an exception when namespace configuration is not available") except ConfigurationNotFoundError: pass # Global configuration self.assertNotIn("global_configuration", self.config.__dict__) self.assertEqual(self.config.global_configuration, "global configuration") try: self.test = self.config.namespace_missing self.fail("ConfigurationType should raise an exception when global configuration is not available") except ConfigurationNotFoundError: pass def test_update_using_update(self): # Test (partial) updating self.config.update({"test": "public 2"}) self.assertEqual(self.config.test, "public 2") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.config.update({"_test2": "protected 2", "_test3": "private 2", "$test4": "variable 2"}) self.assertEqual(self.config.test, "public 2") self.assertEqual(self.config.test2, "protected 2") self.assertEqual(self.config.test3, "private 2") self.assertEqual(self.config.test4, "variable 2") # Test private configuration detection self.config._private.append("_private_also") self.config.update({"private_also": "private"}) self.assertEqual(self.config.private_also, "private") self.assertEqual(self.config._private_also, "private") def test_to_dict(self): # Get all different possibilities private = self.config.to_dict(private=True) protected = self.config.to_dict(protected=True) public = self.config.to_dict() everything = self.config.to_dict(private=True, protected=True) # Check properties self.assertIn("_test3", private) self.assertIn("test", private) self.assertIn("$test4", private) self.assertNotIn("_test2", private) self.assertIn("_test2", protected) self.assertIn("test", protected) self.assertIn("$test4", protected) self.assertNotIn("_test3", protected) self.assertIn("test", public) self.assertIn("$test4", public) self.assertNotIn("_test2", public) self.assertNotIn("_test3", public) self.assertIn("test", everything) self.assertIn("_test2", everything) self.assertIn("_test3", everything) self.assertIn("$test4", everything) # Make sure that all private keys are there # But the defaults key should not be passed down self.assertEqual(len(self.config._private) - 1 + len(public), len(private)) def test_from_dict(self): # Call with correct dict type_instance = ConfigurationType.from_dict( self.config.to_dict(private=True, protected=True), MOCK_CONFIGURATION ) self.assertEqual(type_instance.test, "public") self.assertEqual(type_instance.test2, "protected") self.assertEqual(type_instance.test3, "private") self.assertEqual(type_instance.test4, "variable") self.assertEqual(type_instance.global_configuration, "global configuration") self.assertEqual(type_instance.namespace_configuration, "namespace configuration") self.assertEqual(type_instance._private, self.config._private) # Call with malformed dicts try: ConfigurationType.from_dict({"_namespace": "test"}, MOCK_CONFIGURATION) self.fail("from_dict does not fail if _private is missing from configuration.") except AssertionError: pass try: ConfigurationType.from_dict({"_private": "test"}, MOCK_CONFIGURATION) self.fail("from_dict does not fail if _namespace is missing from configuration.") except AssertionError: pass def test_contains(self): self.assertTrue("test" in self.config) self.assertTrue("test2" in self.config) self.assertTrue("test3" in self.config) self.assertTrue("_test2" in self.config) self.assertTrue("_test3" in self.config) self.assertTrue("test4" in self.config) self.assertFalse("test5" in self.config) @patch("datagrowth.configuration.types.ConfigurationType.update") def test_supplement(self, update_method): self.config.supplement({"test": "public 2"}) self.assertEqual(self.config.test, "public") update_method.assert_not_called() self.config.supplement({"_test2": "protected 2", "_test3": "private 2", "$test4": "variable 2"}) self.assertEqual(self.config.test, "public") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.assertEqual(self.config.test4, "variable") update_method.assert_not_called() self.config.supplement({"new": "new", "_new2": "new 2", "$new3": "new 3"}) update_method.assert_called_once_with({"new": "new", "_new2": "new 2", "$new3": "new 3"}) def test_items(self): # Get all different possibilities private = self.config.items(private=True) protected = self.config.items(protected=True) public = self.config.items() everything = self.config.items(private=True, protected=True) # Check types self.assertIsInstance(private, Iterator) self.assertIsInstance(protected, Iterator) self.assertIsInstance(public, Iterator) self.assertIsInstance(everything, Iterator) # Convert to more predictable dicts private = dict(private) protected = dict(protected) public = dict(public) everything = dict(everything) # Check properties self.assertIn("_test3", private) self.assertIn("test", private) self.assertIn("$test4", private) self.assertNotIn("_test2", private) self.assertIn("_test2", protected) self.assertIn("test", protected) self.assertIn("$test4", protected) self.assertNotIn("_test3", protected) self.assertIn("test", public) self.assertIn("$test4", public) self.assertNotIn("_test2", public) self.assertNotIn("_test3", public) self.assertIn("test", everything) self.assertIn("_test2", everything) self.assertIn("_test3", everything) self.assertIn("$test4", everything) # Make sure that all private keys are there # But the defaults key should not be passed down self.assertEqual(len(self.config._private) - 1 + len(public), len(private)) def test_clean_key(self): variable_key = "$variable" protected_key = "_protected" weird_key = ",weird" self.assertEqual(self.config.clean_key(variable_key), "variable") self.assertEqual(self.config.clean_key(protected_key), "protected") self.assertEqual(self.config.clean_key(weird_key), ",weird") def test_get(self): self.assertEqual(self.config.get("test", None), "public") self.assertEqual(self.config.get("test2", None), "protected") self.assertEqual(self.config.get("test3", None), "private") self.assertEqual(self.config.get("_test2", None), "protected") self.assertEqual(self.config.get("_test3", None), "private") self.assertEqual(self.config.get("test4", None), "variable") # Default fallback self.assertEqual(self.config.get("test5", "does-not-exist"), "does-not-exist") self.assertEqual(self.config.get("test5", 0), 0) self.assertEqual(self.config.get("test5", None), None) # Namespace configuration (with a list default) self.assertNotIn("namespace_configuration", self.config.__dict__) self.assertEqual(self.config.get("namespace_configuration", None), "namespace configuration") self.assertEqual(self.config.get("namespace_missing", ["missing namespace"]), ["missing namespace"]) # Global configuration (with a dict default) self.assertNotIn("global_configuration", self.config.__dict__) self.assertEqual(self.config.get("global_configuration", None), "global configuration") self.assertEqual(self.config.get("global_missing", {"global missing": True}), {"global missing": True}) try: self.test = self.config.get("test5") self.fail( "ConfigurationType.get should raise an exception " "when configuration is not available and no default is set" ) except ConfigurationNotFoundError: pass
class TestConfigurationType(TestCase): def setUp(self): super().setUp() self.config = ConfigurationType(namespace="name", private=["_test3"], defaults=MOCK_CONFIGURATION) self.config.update({ "test": "public", "_test2": "protected", "_test3": "private", "$test4": "variable" # variable config is not recommended }) def test_init(self): # Implicit init without defaults # Notice that apps can manipulate the DATAGROWTH_DEFAULT_CONFIGURATION upon app.ready # Therefor defaults are not loaded until first access instance = ConfigurationType() self.assertEqual(instance._defaults, None) self.assertEqual(instance._namespace, ConfigurationType._global_prefix) self.assertEqual(instance._private, ConfigurationType._private_defaults) purge_immediately = instance.purge_immediately # this loads the defaults self.assertFalse(purge_immediately) self.assertEqual(instance._defaults, DATAGROWTH_DEFAULT_CONFIGURATION) # Implicit init with defaults instance = ConfigurationType(defaults=MOCK_CONFIGURATION) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) self.assertEqual(instance._namespace, ConfigurationType._global_prefix) self.assertEqual(instance._private, ConfigurationType._private_defaults) purge_immediately = instance.purge_immediately # this won't load defaults as defaults got set self.assertFalse(purge_immediately) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) # Explicit init with double private key instance = ConfigurationType(namespace="name", private=["_test", "_test", "oops"], defaults=MOCK_CONFIGURATION) self.assertEqual(instance._defaults, MOCK_CONFIGURATION) self.assertEqual(instance._namespace, "name") self.assertEqual( instance._private, ConfigurationType._private_defaults + ["_test", "_oops"]) def test_attribute_access(self): self.assertEqual(self.config.test, "public") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.assertEqual(self.config._test2, "protected") self.assertEqual(self.config._test3, "private") self.assertEqual(self.config.test4, "variable") # Not found error try: self.test = self.config.test5 self.fail( "ConfigurationType should raise an exception when configuration is not available" ) except ConfigurationNotFoundError: pass # Namespace configuration self.assertNotIn("namespace_configuration", self.config.__dict__) self.assertEqual(self.config.namespace_configuration, "namespace configuration") try: self.test = self.config.namespace_missing self.fail( "ConfigurationType should raise an exception when namespace configuration is not available" ) except ConfigurationNotFoundError: pass # Global configuration self.assertNotIn("global_configuration", self.config.__dict__) self.assertEqual(self.config.global_configuration, "global configuration") try: self.test = self.config.namespace_missing self.fail( "ConfigurationType should raise an exception when global configuration is not available" ) except ConfigurationNotFoundError: pass def test_update_using_update(self): # Test (partial) updating self.config.update({"test": "public 2"}) self.assertEqual(self.config.test, "public 2") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.config.update({ "_test2": "protected 2", "_test3": "private 2", "$test4": "variable 2" }) self.assertEqual(self.config.test, "public 2") self.assertEqual(self.config.test2, "protected 2") self.assertEqual(self.config.test3, "private 2") self.assertEqual(self.config.test4, "variable 2") # Test private configuration detection self.config._private.append("_private_also") self.config.update({"private_also": "private"}) self.assertEqual(self.config.private_also, "private") self.assertEqual(self.config._private_also, "private") def test_to_dict(self): # Get all different possibilities private = self.config.to_dict(private=True) protected = self.config.to_dict(protected=True) public = self.config.to_dict() everything = self.config.to_dict(private=True, protected=True) # Check properties self.assertIn("_test3", private) self.assertIn("test", private) self.assertIn("$test4", private) self.assertNotIn("_test2", private) self.assertIn("_test2", protected) self.assertIn("test", protected) self.assertIn("$test4", protected) self.assertNotIn("_test3", protected) self.assertIn("test", public) self.assertIn("$test4", public) self.assertNotIn("_test2", public) self.assertNotIn("_test3", public) self.assertIn("test", everything) self.assertIn("_test2", everything) self.assertIn("_test3", everything) self.assertIn("$test4", everything) # Make sure that all private keys are there # But the defaults key should not be passed down self.assertEqual( len(self.config._private) - 1 + len(public), len(private)) def test_from_dict(self): # Call with correct dict type_instance = ConfigurationType.from_dict( self.config.to_dict(private=True, protected=True), MOCK_CONFIGURATION) self.assertEqual(type_instance.test, "public") self.assertEqual(type_instance.test2, "protected") self.assertEqual(type_instance.test3, "private") self.assertEqual(type_instance.test4, "variable") self.assertEqual(type_instance.global_configuration, "global configuration") self.assertEqual(type_instance.namespace_configuration, "namespace configuration") self.assertEqual(type_instance._private, self.config._private) # Call with malformed dicts try: ConfigurationType.from_dict({"_namespace": "test"}, MOCK_CONFIGURATION) self.fail( "from_dict does not fail if _private is missing from configuration." ) except AssertionError: pass try: ConfigurationType.from_dict({"_private": "test"}, MOCK_CONFIGURATION) self.fail( "from_dict does not fail if _namespace is missing from configuration." ) except AssertionError: pass def test_contains(self): self.assertTrue("test" in self.config) self.assertTrue("test2" in self.config) self.assertTrue("test3" in self.config) self.assertTrue("_test2" in self.config) self.assertTrue("_test3" in self.config) self.assertTrue("test4" in self.config) self.assertFalse("test5" in self.config) @patch("datagrowth.configuration.types.ConfigurationType.update") def test_supplement(self, update_method): self.config.supplement({"test": "public 2"}) self.assertEqual(self.config.test, "public") update_method.assert_not_called() self.config.supplement({ "_test2": "protected 2", "_test3": "private 2", "$test4": "variable 2" }) self.assertEqual(self.config.test, "public") self.assertEqual(self.config.test2, "protected") self.assertEqual(self.config.test3, "private") self.assertEqual(self.config.test4, "variable") update_method.assert_not_called() self.config.supplement({ "new": "new", "_new2": "new 2", "$new3": "new 3" }) update_method.assert_called_once_with({ "new": "new", "_new2": "new 2", "$new3": "new 3" }) def test_items(self): # Get all different possibilities private = self.config.items(private=True) protected = self.config.items(protected=True) public = self.config.items() everything = self.config.items(private=True, protected=True) # Check types self.assertIsInstance(private, Iterator) self.assertIsInstance(protected, Iterator) self.assertIsInstance(public, Iterator) self.assertIsInstance(everything, Iterator) # Convert to more predictable dicts private = dict(private) protected = dict(protected) public = dict(public) everything = dict(everything) # Check properties self.assertIn("_test3", private) self.assertIn("test", private) self.assertIn("$test4", private) self.assertNotIn("_test2", private) self.assertIn("_test2", protected) self.assertIn("test", protected) self.assertIn("$test4", protected) self.assertNotIn("_test3", protected) self.assertIn("test", public) self.assertIn("$test4", public) self.assertNotIn("_test2", public) self.assertNotIn("_test3", public) self.assertIn("test", everything) self.assertIn("_test2", everything) self.assertIn("_test3", everything) self.assertIn("$test4", everything) # Make sure that all private keys are there # But the defaults key should not be passed down self.assertEqual( len(self.config._private) - 1 + len(public), len(private)) def test_clean_key(self): variable_key = "$variable" protected_key = "_protected" weird_key = ",weird" self.assertEqual(self.config.clean_key(variable_key), "variable") self.assertEqual(self.config.clean_key(protected_key), "protected") self.assertEqual(self.config.clean_key(weird_key), ",weird") def test_get(self): self.assertEqual(self.config.get("test", None), "public") self.assertEqual(self.config.get("test2", None), "protected") self.assertEqual(self.config.get("test3", None), "private") self.assertEqual(self.config.get("_test2", None), "protected") self.assertEqual(self.config.get("_test3", None), "private") self.assertEqual(self.config.get("test4", None), "variable") # Default fallback self.assertEqual(self.config.get("test5", "does-not-exist"), "does-not-exist") self.assertEqual(self.config.get("test5", 0), 0) self.assertEqual(self.config.get("test5", None), None) # Namespace configuration (with a list default) self.assertNotIn("namespace_configuration", self.config.__dict__) self.assertEqual(self.config.get("namespace_configuration", None), "namespace configuration") self.assertEqual( self.config.get("namespace_missing", ["missing namespace"]), ["missing namespace"]) # Global configuration (with a dict default) self.assertNotIn("global_configuration", self.config.__dict__) self.assertEqual(self.config.get("global_configuration", None), "global configuration") self.assertEqual( self.config.get("global_missing", {"global missing": True}), {"global missing": True}) try: self.test = self.config.get("test5") self.fail( "ConfigurationType.get should raise an exception " "when configuration is not available and no default is set") except ConfigurationNotFoundError: pass