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)