def test_instance_level_1_relation(self):
create_samples(continent_names=['europe'],
country_names=['germany'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
langs=['de', 'tr'])
lvl_1 = ('countries', )
europe = Continent.objects.get(code='EU')
germany = europe.countries.all()[0]
hierarchy = _get_relations_hierarchy(*lvl_1)
ct_continent = ContentType.objects.get_for_model(Continent)
ct_country = ContentType.objects.get_for_model(Country)
mapping, query = _get_purview(europe, hierarchy)
self.assertDictEqual(
mapping, {
ct_continent.id: {
str(europe.pk): europe
},
ct_country.id: {
str(germany.pk): germany
}
})
def test_prefetched_queryset_level_1_relation(self):
create_samples(continent_names=['europe', 'asia'],
country_names=['germany', 'south korea'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
langs=['de', 'tr'])
lvl_1 = ('countries', )
continents = Continent.objects.prefetch_related(*lvl_1)
europe = [x for x in continents if x.code == 'EU'][0]
germany = europe.countries.all()[0]
asia = [x for x in continents if x.code == 'AS'][0]
south_korea = asia.countries.all()[0]
hierarchy = _get_relations_hierarchy(*lvl_1)
ct_continent = ContentType.objects.get_for_model(Continent)
ct_country = ContentType.objects.get_for_model(Country)
mapping, query = _get_purview(continents, hierarchy)
self.assertDictEqual(
mapping, {
ct_continent.id: {
str(europe.pk): europe,
str(asia.pk): asia
},
ct_country.id: {
str(germany.pk): germany,
str(south_korea.pk): south_korea
},
})
def test_prefetched_instance_level_2_relation(self):
create_samples(continent_names=['europe'],
country_names=['germany'],
city_names=['cologne'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
city_fields=['name', 'denonym'],
langs=['de', 'tr'])
lvl_2 = ('countries__cities', )
europe = Continent.objects.prefetch_related(*lvl_2).get(code='EU')
germany = europe.countries.all()[0]
cologne = germany.cities.all()[0]
hierarchy = _get_relations_hierarchy(*lvl_2)
ct_continent = ContentType.objects.get_for_model(Continent)
ct_city = ContentType.objects.get_for_model(City)
mapping, query = _get_purview(europe, hierarchy)
self.assertDictEqual(
mapping, {
ct_continent.id: {
str(europe.pk): europe
},
ct_city.id: {
str(cologne.id): cologne
}
})
def test_queryset_level_1_2_relation_with_lang(self):
create_samples(continent_names=['europe', 'asia'],
country_names=['germany', 'south korea'],
city_names=['cologne', 'seoul'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
city_fields=['name', 'denonym'],
langs=['de', 'tr'])
lvl_1_2 = (
'countries',
'countries__cities',
)
continents = Continent.objects.all()
hierarchy = _get_relations_hierarchy(*lvl_1_2)
mapping, query = _get_purview(continents, hierarchy)
self.assertQuerysetEqual(
_get_translations(query, 'de').order_by('id'), [
'<Translation: Europe: Europa>',
'<Translation: European: Europäisch>',
'<Translation: Germany: Deutschland>',
'<Translation: German: Deutsche>',
'<Translation: Cologne: Köln>',
'<Translation: Cologner: Kölner>',
'<Translation: Asia: Asien>',
'<Translation: Asian: Asiatisch>',
'<Translation: South Korea: Südkorea>',
'<Translation: South Korean: Südkoreanisch>',
'<Translation: Seoul: Seül>',
'<Translation: Seouler: Seüler>',
])
def test_many_included_level_1_and_many_nested_level_2_relations(self):
self.assertEqual(
_get_relations_hierarchy('countries', 'countries__cities',
'countries__currency', 'unions',
'unions__projects', 'unions__currency'), {
'countries': {
'included': True,
'relations': {
'cities': {
'included': True,
'relations': {}
},
'currency': {
'included': True,
'relations': {}
}
}
},
'unions': {
'included': True,
'relations': {
'projects': {
'included': True,
'relations': {}
},
'currency': {
'included': True,
'relations': {}
}
}
},
})
def test_many_unincluded_level_1_and_one_nested_level_2_relation(self):
self.assertEqual(
_get_relations_hierarchy(
'countries__cities',
'unions__projects',
), {
'countries': {
'included': False,
'relations': {
'cities': {
'included': True,
'relations': {}
}
}
},
'unions': {
'included': False,
'relations': {
'projects': {
'included': True,
'relations': {}
}
}
}
})
def test_instance_level_1_2_relation_with_lang(self):
create_samples(continent_names=['europe'],
country_names=['germany'],
city_names=['cologne'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
city_fields=['name', 'denonym'],
langs=['de', 'tr'])
lvl_1_2 = (
'countries',
'countries__cities',
)
europe = Continent.objects.get(code='EU')
hierarchy = _get_relations_hierarchy(*lvl_1_2)
mapping, query = _get_purview(europe, hierarchy)
self.assertQuerysetEqual(
_get_translations(query, 'de').order_by('id'), [
'<Translation: Europe: Europa>',
'<Translation: European: Europäisch>',
'<Translation: Germany: Deutschland>',
'<Translation: German: Deutsche>',
'<Translation: Cologne: Köln>',
'<Translation: Cologner: Kölner>',
])
def test_many_level_1_relations(self):
self.assertEqual(
_get_relations_hierarchy('countries', 'unions'), {
'countries': {
'included': True,
'relations': {}
},
'unions': {
'included': True,
'relations': {}
},
})
def test_one_included_level_1_and_one_nested_level_2_relation(self):
self.assertEqual(
_get_relations_hierarchy('countries', 'countries__cities'), {
'countries': {
'included': True,
'relations': {
'cities': {
'included': True,
'relations': {}
}
}
}
})
def test_prefetched_instance_level_0_relation(self):
create_samples(continent_names=['europe'],
continent_fields=['name', 'denonym'],
langs=['de', 'tr'])
europe = Continent.objects.get(code='EU')
hierarchy = _get_relations_hierarchy()
ct_continent = ContentType.objects.get_for_model(Continent)
mapping, query = _get_purview(europe, hierarchy)
self.assertDictEqual(mapping,
{ct_continent.id: {
str(europe.pk): europe
}})
def test_queryset_level_0_relation_with_lang(self):
create_samples(continent_names=['europe', 'asia'],
country_names=['germany', 'south korea'],
city_names=['cologne', 'seoul'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
city_fields=['name', 'denonym'],
langs=['de', 'tr'])
continents = Continent.objects.all()
hierarchy = _get_relations_hierarchy()
mapping, query = _get_purview(continents, hierarchy)
self.assertQuerysetEqual(
_get_translations(query, 'de').order_by('id'), [
'<Translation: Europe: Europa>',
'<Translation: European: Europäisch>',
'<Translation: Asia: Asien>',
'<Translation: Asian: Asiatisch>',
])
def test_queryset_level_2_relation(self):
create_samples(continent_names=['europe', 'asia'],
country_names=['germany', 'south korea'],
city_names=['cologne', 'seoul'],
continent_fields=['name', 'denonym'],
country_fields=['name', 'denonym'],
city_fields=['name', 'denonym'],
langs=['de', 'tr'])
lvl_2 = ('countries__cities', )
continents = Continent.objects.all()
europe = [x for x in continents if x.code == 'EU'][0]
germany = europe.countries.all()[0]
cologne = germany.cities.all()[0]
asia = [x for x in continents if x.code == 'AS'][0]
south_korea = asia.countries.all()[0]
seoul = south_korea.cities.all()[0]
hierarchy = _get_relations_hierarchy(*lvl_2)
ct_continent = ContentType.objects.get_for_model(Continent)
ct_city = ContentType.objects.get_for_model(City)
mapping, query = _get_purview(continents, hierarchy)
self.assertDictEqual(
mapping, {
ct_continent.id: {
str(europe.pk): europe,
str(asia.pk): asia
},
ct_city.id: {
str(cologne.id): cologne,
str(seoul.id): seoul
}
})
def test_prefetched_queryset_level_0_relation(self):
create_samples(continent_names=['europe', 'asia'],
continent_fields=['name', 'denonym'],
langs=['de', 'tr'])
continents = Continent.objects.all()
europe = [x for x in continents if x.code == 'EU'][0]
asia = [x for x in continents if x.code == 'AS'][0]
hierarchy = _get_relations_hierarchy()
ct_continent = ContentType.objects.get_for_model(Continent)
mapping, query = _get_purview(continents, hierarchy)
self.assertDictEqual(mapping, {
ct_continent.id: {
str(europe.pk): europe,
str(asia.pk): asia
},
})
def __init__(self, entity, *relations):
"""Initialize a `Context` with an entity and some relations of it."""
hierarchy = _get_relations_hierarchy(*relations)
self.mapping, self.query = _get_purview(entity, hierarchy)
def test_one_level_1_relation(self):
self.assertEqual(_get_relations_hierarchy('countries'),
{'countries': {
'included': True,
'relations': {}
}})
def test_level_0_relation(self):
self.assertDictEqual(_get_relations_hierarchy(), {})
