def test_get_enabled_chunks_for_region_bad_models_loud_fail(self):
blank_conf = EditRegionConfiguration()
error = ImproperlyConfigured
if is_django_17plus():
error = LookupError
with self.assertRaises(error):
blank_conf.get_enabled_chunks_for_region({"x.Y": 1})
def test_configure_basic(self):
user = self.model_dependencies["user"]
blank_conf = EditRegionConfiguration()
blank_conf.configure(obj=user)
self.assertEqual(blank_conf.obj, user)
self.assertTrue(blank_conf.has_configuration)
self.assertEqual(blank_conf.config, {})
def test_bool(self):
blank_conf = EditRegionConfiguration()
blank_conf.has_configuration = True
blank_conf.config = {"x": 1}
self.assertTrue(blank_conf)
blank_conf2 = EditRegionConfiguration()
self.assertFalse(blank_conf2)
def test_get_template_region_configuration_no_names_fallback(self):
blank_conf = EditRegionConfiguration()
template = Template(
"""{
"x": {}
}"""
)
raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
result = blank_conf.get_template_region_configuration(raw_data=raw_config)
self.assertEqual(result, {"x": {"name": "x", "models": {}}})
def test_configure_template_discovered(self):
"""
We can't test for the Template instance directly, as it's no longer
exposed on the object.
Given the template `sample_editregion_template.html` has nothing in it,
the config should become an empty dict.
"""
user = self.model_dependencies["user"]
blank_conf = EditRegionConfiguration()
blank_conf.configure(obj=user)
self.assertEqual({}, blank_conf.config)
def test_dissecting_subclasses(self):
args = ("zzz__yyy__xxx", "a", "b", "zzz__yyy", "c", "zzz", "e", "f", "c__d", "g", "h", "i", "j", "k")
expected = (
("c", "c__d"),
("zzz", "zzz__yyy", "zzz__yyy__xxx"),
("a", "b", "e", "f", "g", "h", "i"),
("j", "k"),
)
blank_conf = EditRegionConfiguration()
result = blank_conf._dissect_subclasses(args, split_after=7)
self.assertEqual(result, expected)
def test_dissecting_subclasses_with_stupid_skip(self):
"""
with a split of 1, don't conjoin the last relation with the previous
eg, don't do: ('a', ('b', 'c')), instead do: (('a',), ('b',), ('c',))
grandparents and stuff are still all selected at once, you cretin.
"""
args = ("a", "b", "c", "a__b", "d", "e", "f", "g")
blank_conf = EditRegionConfiguration()
result = blank_conf._dissect_subclasses(args, split_after=1)
expected = (("a", "a__b"), ("b",), ("c",), ("d",), ("e",), ("f",), ("g",))
self.assertEqual(result, expected)
def test_configure_template_not_discovered(self):
user = self.model_dependencies["user"]
blank_conf = EditRegionConfiguration()
try:
admin.site.unregister(User)
except NotRegistered:
pass
admin.site.register(User, TestBadUserAdmin)
with self.settings(DEBUG=True):
with self.assertRaises(TemplateDoesNotExist):
blank_conf.configure(obj=user)
with self.settings(DEBUG=False):
blank_conf.configure(obj=user)
self.assertFalse(blank_conf.has_configuration)
def test_inequality(self):
blank_conf = EditRegionConfiguration()
blank_conf.has_configuration = True
blank_conf.config = {"x": 1, "y": 2}
blank_conf2 = EditRegionConfiguration()
blank_conf2.has_configuration = True
blank_conf2.config = {"x": 1}
self.assertNotEqual(blank_conf, blank_conf2)
def test_lessthanequal(self):
blank_conf = EditRegionConfiguration()
blank_conf.has_configuration = True
blank_conf.config = {"x": 1, "y": 2}
blank_conf2 = EditRegionConfiguration()
blank_conf2.has_configuration = True
blank_conf2.config = {"x": 1}
self.assertLessEqual(blank_conf2, blank_conf)
def test_greaterthanequal(self):
blank_conf = EditRegionConfiguration()
blank_conf.has_configuration = True
blank_conf.config = {"x": 1, "y": 2}
blank_conf2 = EditRegionConfiguration()
blank_conf2.has_configuration = True
blank_conf2.config = {"x": 1}
self.assertGreaterEqual(blank_conf, blank_conf2)
def test_fetch_chunks_for_obj_noregions(self):
user, created = User.objects.get_or_create(username="******")
blank_conf = EditRegionConfiguration(obj=user)
template = Template(
"""{
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
results = blank_conf.fetch_chunks_for(region="x")
self.assertEqual((), results)
def test_fetch_chunks_for_no_obj_debug_true(self):
blank_conf = EditRegionConfiguration()
template = Template(
"""{
"x": {
"name": "test"
}
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
with self.settings(DEBUG=True):
with self.assertRaises(ImproperlyConfigured):
blank_conf.fetch_chunks_for(region="x")
def test_get_limits_for_no_models(self):
blank_conf = EditRegionConfiguration()
template = Template(
"""{
"x": {
"name": "test"
}
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
result = blank_conf.get_limits_for(region="x", chunk=User)
self.assertEqual(0, result)
def test_fetch_chunks(self):
user, created = User.objects.get_or_create(username="******")
blank_conf = EditRegionConfiguration(obj=user)
template = Template(
"""{
"x": {},
"y": {},
"z": {}
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
results = blank_conf.fetch_chunks()
self.assertEqual(dict(results), {u"y": [], u"x": [], u"z": []})
def test_fetch_chunks_for_no_obj_debug_false(self):
blank_conf = EditRegionConfiguration()
template = Template(
"""{
"x": {
"name": "test"
}
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
with self.settings(DEBUG=False):
result = blank_conf.fetch_chunks_for(region="x")
self.assertEqual([], result)
def test_get_limits_for(self):
blank_conf = EditRegionConfiguration()
template = Template(
"""{
"x": {
"name": "test",
"models": {
"auth.User": 1,
"auth.Group": 0,
"auth.Permission": null
}
}
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
result = blank_conf.get_limits_for(region="x", chunk=User)
self.assertEqual(1, result)
# 0 means don't show up!
result = blank_conf.get_limits_for(region="x", chunk=Group)
self.assertEqual(0, result)
result = blank_conf.get_limits_for(region="x", chunk=Permission)
self.assertEqual(None, result)
def test_json_serializer(self):
user, created = User.objects.get_or_create(username="******")
blank_conf = EditRegionConfiguration(obj=user)
template = Template(
"""{
"test": {
"name": "whee!",
"models": {
"embeds.Iframe": 2
}
},
"test2": {
"name": "oh my goodness, another test region",
"models": {
"embeds.Iframe": 1
}
},
"test3": {
"name": "oh my goodness, yet another test region",
"models": {
"embeds.Iframe": null
}
}
}"""
)
blank_conf.raw_config = blank_conf.decode_template_region_configuration(template_instance=template)
blank_conf.config = blank_conf.get_template_region_configuration(raw_data=blank_conf.raw_config)
self.assertEqual(
dict(blank_conf.config),
{
"test": {"models": {Iframe: 2}, "name": "whee!"},
"test2": {"models": {Iframe: 1}, "name": "oh my goodness, another test region"},
"test3": {"models": {Iframe: None}, "name": "oh my goodness, yet another test region"},
},
)
results = blank_conf.fetch_chunks()
self.assertEqual(dict(results), {"test": [], "test3": [], "test2": []})
def test_get_template_region_configuration_failed_json_decoding(self):
blank_conf = EditRegionConfiguration()
template = Template("xyz")
with self.assertRaisesRegexp(ValueError, r"No JSON object could be decoded"):
blank_conf.decode_template_region_configuration(template_instance=template)
def test_dissecting_subclasses_with_only_deep_descendants(self):
args = ("a", "b", "a__c", "b__d", "b__d__e", "a__e")
blank_conf = EditRegionConfiguration()
result = blank_conf._dissect_subclasses(args, split_after=7)
expected = (("a", "a__c", "a__e"), ("b", "b__d", "b__d__e"))
self.assertEqual(result, expected)
def test_dissecting_subclasses_with_no_items(self):
args = ()
blank_conf = EditRegionConfiguration()
result = blank_conf._dissect_subclasses(args, split_after=7)
expected = ()
self.assertEqual(result, expected)
def test_get_first_valid_template_string_input(self):
blank_conf = EditRegionConfiguration()
templates = "sample_editregion_template.html"
received = blank_conf.get_first_valid_template(possible_templates=templates)
self.assertIsInstance(received, Template)
def test_dissecting_subclasses_one_leftover_crossing_relations(self):
args = ("a", "b", "c", "a__b", "d", "e", "f", "g")
blank_conf = EditRegionConfiguration()
result = blank_conf._dissect_subclasses(args, split_after=5)
expected = (("a", "a__b"), ("b", "c", "d", "e", "f", "g"))
self.assertEqual(result, expected)
def test_get_enabled_chunks_for_region_bad_models_loud_fail2(self):
blank_conf = EditRegionConfiguration()
with self.assertRaisesRegexp(ImproperlyConfigured, r'Unable to load model "Y" from app "auth"'): # noqa
blank_conf.get_enabled_chunks_for_region({"auth.Y": 1})
def test_get_first_valid_template_failed(self):
blank_conf = EditRegionConfiguration()
templates = ["zzzzzz.html"]
received = blank_conf.get_first_valid_template(possible_templates=templates)
self.assertIsNone(received)
def test_get_enabled_chunks_for_region_empty(self):
blank_conf = EditRegionConfiguration()
expected = {}
received = blank_conf.get_enabled_chunks_for_region({})
self.assertEqual(expected, received)
def test_dissecting_subclasses_not_enough(self):
args = ("a", "b", "c", "d", "e", "f")
blank_conf = EditRegionConfiguration()
result = blank_conf._dissect_subclasses(args, split_after=7)
self.assertEqual(result, (args,))
def test_get_enabled_chunks_for_region_bad_models_silent_fail(self):
blank_conf = EditRegionConfiguration()
expected = {User: 1, Group: None}
received = blank_conf.get_enabled_chunks_for_region({"auth.User": 1, "auth.Group": None, "x.Y": 1})
self.assertEqual(expected, received)
