def test_singleton_contextually_presents_different_values(self): Mode = settings_handler.Mode modes = list(Mode) metaclass = settings_handler.Singleton results = [] for some_mode in modes: try: instantiated = False singleton = settings_handler.Settings(self.inifile, mode=some_mode) except Exception as e: raise else: instantiated = True contextual_value = singleton.log_filename results.append(contextual_value) finally: # cleanup and reset singeton if instantiated: metaclass.reset_singleton(type(singleton)) msg = "The values of the attribute did not vary with context." set_length = len(set(results)) self.assertEqual(set_length, len(results), msg=msg)
def test_specific_attribute_SCHEMA(self): singleton = settings_handler.Settings(self.inifile) var = singleton.schema expected_type = etree.XMLSchema self.assertIsInstance(var, expected_type)
def test_singleton_has_mode_attr(self): live = settings_handler.Mode.LIVE expected_attr = "mode" singleton = settings_handler.Settings(self.inifile, mode=live) self.assertHasAttr(obj=singleton, attrname=expected_attr)
def test_singleton_mode_attr_is_enum(self): import enum live = settings_handler.Mode.LIVE singleton = settings_handler.Settings(self.inifile, mode=live) self.assertIsInstance(singleton.mode, enum.Enum) self.assertIsInstance(singleton.mode, settings_handler.Mode)
def test_has_expected_attributes(self): attrs = self.expected_attributes singleton = settings_handler.Settings(self.inifile) for expected in attrs: with self.subTest(attrname=expected): self.assertHasAttr(obj=singleton, attrname=expected)
def test_has_no_unexpected_attributes(self): expected_attrs = set(self.expected_attributes) singleton = settings_handler.Settings(self.inifile) attrs = (a for a in dir(singleton) if not a.startswith("_")) for actual in attrs: with self.subTest(unepexcted_attr=actual): msg = f"Suprise: did not expect to find 'singleton.{actual}'" self.assertIn(actual, expected_attrs, msg=msg)
def test_singleton_mode_defaults_to_live(self): Mode = settings_handler.Mode expected_mode = Mode.LIVE wrong_modes = [m for m in list(Mode) if m is not expected_mode] singleton = settings_handler.Settings(self.inifile) self.assertIs(singleton.mode, expected_mode) self.assertEqual(singleton.mode, expected_mode) for some_mode in wrong_modes: with self.subTest(wrong_mode=some_mode): self.assertIsNot(singleton.mode, some_mode) self.assertNotEqual(singleton.mode, some_mode)
def test_attributes_are_not_settable(self): singleton = settings_handler.Settings(self.inifile) # No magic or 'private' attributes attributes = [a for a in dir(singleton) if not a.startswith("_")] if len(attributes) < 1: self.fail("Not Written") some_var = str(time.time()) # Unique string. for attribute in attributes: with self.subTest(attr=attribute): with self.assertRaises(AttributeError): setattr(singleton, attribute, some_var)
def test_singleton_class_accepts_mode_kwarg(self): live = settings_handler.Mode.LIVE try: settings_handler.Settings(self.inifile, mode=live) except TypeError as err: err_msg = str(err) err_kwarg = "keyword argument" if err_msg in err_kwarg: assertion_msg = "TypeError due to bad keyword argument." self.fail(assertion_msg) else: raise else: pass # pass test if kwarg is accepted
def test_specific_attribute_LOG_FILENAME(self): singleton = settings_handler.Settings(self.inifile) var = singleton.log_filename dest_dir = os.path.dirname(var) isAbsolute = dest_dir.startswith("/") isExpandedUser = "******" in dest_dir self.assertIsInstance(var, (str, pathlib.Path)) self.assertTrue(os.path.isdir(dest_dir), f"Dir: {dest_dir}") self.assertTrue(isAbsolute, f"Dir: {dest_dir} is not an absolute path.") self.assertFalse(isExpandedUser, f"Dir: {dest_dir} needs userexpansion.")
def test_failed_instantiation_raises_package_error(self): inifile = "Foo" assert not os.path.isfile(inifile), os.path.join(os.getcwd(), inifile) with self.assertRaises(exceptions.FileNotFound): settings_handler.Settings(inifile)
def test_instantiation_requires_ini_argument(self): inifile = self.inifile settings_handler.Settings(inifile)