def test_prep(self): # The `prep` method is expected to be used only from concrete subclasses. with self.assertRaises(TypeError) as cm: VisibilitySettings.prep() self.assertEqual(str(cm.exception), "Only specific visibility settings may be created") # The `prep` method is expected to create a new object in the db, and # return it, populated with the correct data. for model_type, model_class in self.subclasses.items(): with self.subTest(type=model_type): with CaptureQueriesContext( connections[DEFAULT_DB_ALIAS]) as cm: model = model_class.prep() self.assertGreaterEqual( len(cm.captured_queries), 1, "{} queries executed while >= 1 expected\nCaptured queries were:\n{}" .format( len(cm.captured_queries), "\n".join(f"{i}. {query['sql']}" for i, query in enumerate(cm.captured_queries, start=1)))) self.assertStartsWith(cm.captured_queries[-1]['sql'].upper(), 'INSERT INTO') self.assertIsNotNone(model.pk) self.assertIsNone(model.model_id) self.assertEqual(model.model_type, model_type) for opt in self.options: self.assertIsNotNone(getattr(model, opt), msg=f"option {opt}")
def test_type_method(self): with self.assertRaises(TypeError) as cm: VisibilitySettings.type() self.assertEqual( str(cm.exception), "Model type is only defined for specific visibility settings") for model_type, model in self.subclasses.items(): self.assertEqual(model.type(), model_type, msg=f"model {model}")
def test_as_specific_method(self): for model_type, model_class in self.subclasses.items(): with self.subTest(type=model_type): model = model_class() result = model.as_specific() self.assertIs(result, model) self.assertIs(result.__class__, model_class) model = VisibilitySettings(model_type=model_type) result = model.as_specific() self.assertIs(result.__class__, model_class) model = VisibilitySettings(model_type='Dummy') self.assertRaises(NameError, model.as_specific)
def test_repr(self): model = VisibilitySettings() self.assertEqual( repr(model), "<VisibilitySettings for Unknown@None ~ OP:N,OA:N,B:N>") model = VisibilitySettingsForPhone(visible_online_authed=True, visible_in_book=False) self.assertEqual(repr(model), "<VisibilitySettingsForPhone @None ~ OP:N,OA:T,B:F>") model = VisibilitySettings(model_type='Phone', visible_online_public=False) self.assertEqual( repr(model), "<VisibilitySettings for Phone@None ~ OP:F,OA:N,B:N>")
def test_venues_method(self): expected = set(opt[len('visible_'):] for opt in self.options) self.assertEqual(set(VisibilitySettings.venues()), expected) for model in self.subclasses.values(): self.assertEqual(set(model.venues()), expected, msg=f"\nmodel {model}")
def test_fields(self): model = VisibilitySettings() self.assertEqual(model._meta.get_field('model_type').max_length, 25) with translation.override(None): self.assertEqual( model._meta.get_field('model_type').default, 'Unknown') self.assertTrue(model._meta.get_field('model_id').null) self.assertIs( model._meta.get_field('content_type').remote_field.on_delete, CASCADE)
def test_setitem(self): model = VisibilitySettings() for opt in self.options: self.assertIsNone(getattr(model, opt), msg=f"option {opt}") model[opt[len('visible_'):]] = False self.assertFalse(getattr(model, opt), msg=f"option {opt}") # Trying to set an unknown visibility option is expected to raise an error. with self.assertRaises(KeyError) as cm: model['content_type'] = True self.assertEqual(cm.exception.args[0], "Unknown venue 'content_type'")
def test_getitem(self): model = VisibilitySettings() for opt in self.options: self.assertEqual(model[opt[len('visible_'):]], getattr(model, opt)) # Trying to get an unknown visibility option is expected to raise an error. with self.assertRaises(KeyError) as cm: model['dummy'] self.assertEqual(cm.exception.args[0], "Unknown venue 'dummy'") with self.assertRaises(KeyError) as cm: model['model_type'] self.assertEqual(cm.exception.args[0], "Unknown venue 'model_type'")
def test_str(self): test_data = [ ( "generic", VisibilitySettings(), { 'en': "unknown", 'eo': "nekonataĵo" }, ), ( "place", VisibilitySettingsForPlace(model_type='Place'), { 'en': "place", 'eo': "loĝejo" }, ), ( "fm", VisibilitySettingsForFamilyMembers(model_type='FamilyMembers'), { 'en': "family members", 'eo': "kunloĝantoj" }, ), ( "phone", VisibilitySettingsForPhone(model_type='Phone'), { 'en': "phone", 'eo': "telefono" }, ), ( "email", VisibilitySettingsForPublicEmail(model_type='PublicEmail'), { 'en': "public email", 'eo': "publika retpoŝta adreso" }, ) ] for model_tag, model, labels in test_data: with self.subTest(type=model_tag): with override_settings(LANGUAGE_CODE='en'): self.assertEqual( str(model), f"Settings of visibility for {labels['en']}") with override_settings(LANGUAGE_CODE='eo'): self.assertEqual( str(model), f"Agordoj de videbligo por {labels['eo']}")
def test_concealed(self): model = VisibilitySettings() # When none of the visibility options is set, the object is expected # to be considered concealed. for opt in self.options: self.assertIsNone(getattr(model, opt), msg=f"option {opt}") self.assertTrue(model.concealed) # When all visibility options are set to False, the object is expected # to be considered concealed. for opt in self.options: setattr(model, opt, False) self.assertTrue(model.concealed) # When one or more visibility options are set to True, the object is # expected to be considered revealed (not concealed). for opt in self.options: with self.subTest(setting=f"{opt} <- T"): setattr(model, opt, True) self.assertFalse(model.concealed)
def test_printable_default(self): # The default printable (in book) setting is expected to be True. self.assertTrue(VisibilitySettings().printable)
def test_specific_models_method(self): self.assertEqual(VisibilitySettings.specific_models(), self.subclasses) self.assertEqual(VisibilitySettingsForFamilyMembers.specific_models(), self.subclasses)