def test_delete_network_members_provider(self):
self.login_creator()
member_1 = base.DataProviderFactory(
id=1,
name="test member 1",
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T1").pk],
)
member_2 = base.DataProviderFactory(
id=2,
name="test member 2",
is_network=False,
created_by=self.creator,
countries=[base.CountryFactory(code="T2").pk],
)
network = base.DataProviderFactory(
id=3,
is_network=True,
created_by=self.creator,
)
network.members.set([member_1.pk, member_2.pk])
data = dict()
data["members"] = [member_1.pk]
resp = self.client.post(
reverse("provider:edit_network_members",
kwargs={"pk": network.pk}), data)
network.refresh_from_db()
self.assertEqual(resp.status_code, 302)
self.assertEqual(network.members.count(), 1)
self.assertEqual(
network.members.get(id=member_1.pk).name, member_1.name)
def setUp(self):
super().setUp()
countries = [
base.CountryFactory(code="TST1"),
base.CountryFactory(code="TST2")
]
self._DATA = {
'name': 'test name',
'description': 'test description',
'countries': [country.pk for country in countries],
'is_network': True
}
self.details_fields = [
'acronym', 'website', 'address', 'phone', 'email',
'contact_person', 'provider_type', 'data_provider'
]
self.details_required_fields = ['provider_type']
provider_type = base.ProviderTypeFactory()
self._DETAILS_DATA = {
'acronym': 'acronym',
'website': 'http://test.website',
'address': 'test address',
'phone': 'test phone',
'email': '*****@*****.**',
'contact_person': 'test person',
'provider_type': provider_type.pk
}
self.creator = base.UserFactory(username='******')
self.client.force_login(self.creator)
def setUp(self):
super().setUp()
self.data = base.DataFactory(created_by=self.creator)
countries = [base.CountryFactory(code="T1"), base.CountryFactory(code="T2")]
self.provider = base.DataProviderFactory(
countries=countries, created_by=self.creator
)
self._DATA = {"role": 1, "data": self.data.pk, "provider": self.provider.pk}
user = base.UserFactory(username="******")
self.client.force_login(user)
def test_list_provider_json_filter(self):
base.DataProviderFactory(name="Test provider",
created_by=self.creator,
countries=[base.CountryFactory(code='RO')])
base.DataProviderFactory(name="Other provider",
created_by=self.creator,
countries=[base.CountryFactory(code='UK')])
resp = self.client.get(reverse('provider:json'),
{'search[value]': 'Other'})
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIsNot(data['recordsTotal'], 0)
self.assertFalse(data['recordsTotal'] < 2)
self.assertIs(data['recordsFiltered'], 1)
def test_add_non_network_provider(self):
self.erase_logging_file()
data = self._DATA
details_data = self._DETAILS_DATA
data.update(**details_data)
network_1 = base.DataProviderFactory(
name="test network",
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T1").pk],
)
network_2 = base.DataProviderFactory(
name="test network 2",
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T2").pk],
)
data["networks"] = [network_1.pk, network_2.pk]
resp = self.client.post(reverse("provider:add_non_network"), data)
provider = models.DataProvider.objects.last()
details = provider.details.first()
network_1.refresh_from_db()
network_2.refresh_from_db()
data["is_network"] = False
self.assertEqual(resp.status_code, 302)
self.check_object(provider, data)
self.assertEqual(network_1.members.count(), 1)
self.assertEqual(network_1.members.first(), provider)
self.assertEqual(network_2.members.count(), 1)
self.assertEqual(network_2.members.first(), provider)
self.assertEqual(provider.networks.count(), 2)
self.assertIn(network_1, provider.networks.all())
self.assertIn(network_2, provider.networks.all())
self.assertEqual(provider.details.count(), 1)
details_data.pop("provider_type")
for attr in details_data.keys():
self.assertEqual(getattr(details, attr), data[attr])
self.assertEqual(
getattr(details, "provider_type").pk, data["provider_type"])
self.logging()
def setUp(self):
super().setUp()
self.data = base.DataFactory(created_by=self.creator)
countries = [
base.CountryFactory(code='T1'),
base.CountryFactory(code='T2')
]
self.provider = base.DataProviderFactory(countries=countries,
created_by=self.creator)
self._DATA = {
'role': 1,
'data': self.data.pk,
'provider': self.provider.pk
}
user = base.UserFactory(username='******')
self.client.force_login(user)
def test_list_provider_json_filter(self):
base.DataProviderFactory(
name="Test provider",
created_by=self.creator,
countries=[base.CountryFactory(code="RO")],
)
base.DataProviderFactory(
name="Other provider",
created_by=self.creator,
countries=[base.CountryFactory(code="UK")],
)
resp = self.client.get(reverse("provider:json"),
{"search[value]": "Other"})
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIsNot(data["recordsTotal"], 0)
self.assertFalse(data["recordsTotal"] < 2)
self.assertIs(data["recordsFiltered"], 1)
def setUp(self):
super().setUp()
countries = [
base.CountryFactory(code="TST1"),
base.CountryFactory(code="TST2")
]
self._DATA = {
"name": "test name",
"edmo": 234,
"description": "test description",
"countries": [country.pk for country in countries],
"is_network": True,
}
self.details_fields = [
"acronym",
"website",
"address",
"phone",
"email",
"contact_person",
"provider_type",
"data_provider",
]
self.details_required_fields = ["provider_type"]
provider_type = base.ProviderTypeFactory()
self._DETAILS_DATA = {
"acronym": "acronym",
"website": "http://test.website",
"address": "test address",
"phone": "test phone",
"email": "*****@*****.**",
"contact_person": "test person",
"provider_type": provider_type.pk,
}
self.creator = base.UserFactory(username="******")
self.client.force_login(self.creator)
with open(os.devnull, "w") as f:
call_command("search_index", "--rebuild", "-f", stdout=f)
def test_add_non_network_provider_fail_detail_form_validation(self):
self.erase_logging_file()
data = self._DATA
network_1 = base.DataProviderFactory(
name='test network',
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T1").pk])
network_2 = base.DataProviderFactory(
name='test network 2',
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T2").pk])
data['networks'] = [network_1.pk, network_2.pk]
resp = self.client.post(reverse('provider:add_non_network'), data)
detail_errors = {
field: self.REQUIRED_ERROR
for field in self.details_required_fields
}
self.assertDictEqual(resp.context['details'].errors, detail_errors)
def test_edit_network_members_provider(self):
self.login_creator()
member_1 = base.DataProviderFactory(
id=1,
name='test member 1',
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T1").pk])
member_2 = base.DataProviderFactory(
id=2,
name='test member 2',
is_network=False,
created_by=self.creator,
countries=[base.CountryFactory(code="T2").pk])
member_3 = base.DataProviderFactory(
id=3,
name='test member 3',
is_network=True,
created_by=self.creator,
countries=[base.CountryFactory(code="T3").pk])
network = base.DataProviderFactory(is_network=True,
created_by=self.creator)
data = dict()
data['members'] = [member_1.pk, member_2.pk, member_3.pk]
resp = self.client.post(
reverse('provider:edit_network_members',
kwargs={'pk': network.pk}), data)
network.refresh_from_db()
self.assertEqual(resp.status_code, 302)
self.assertEqual(network.members.count(), 3)
self.assertEqual(
network.members.get(id=member_1.pk).name, member_1.name)
self.assertEqual(
network.members.get(id=member_2.pk).name, member_2.name)
self.assertEqual(
network.members.get(id=member_3.pk).name, member_3.name)
def _create_clone_data(self, data):
inspire_themes = [
base.InspireThemeFactory(),
base.InspireThemeFactory()
]
geographical_coverages = [base.CountryFactory(code="T4")]
DATA_FOR_CLONE = {
"name":
data.name,
"note":
"TEST note",
"dissemination":
data.dissemination.pk,
"update_frequency":
data.update_frequency.pk,
"area":
data.area.pk,
"status":
data.status.pk,
"timeliness":
data.timeliness.pk,
"data_policy":
data.data_policy.pk,
"data_type":
data.data_type.pk,
"data_format":
data.data_format.pk,
"start_time_coverage":
datetime.date(day=1, month=1, year=2000),
"end_time_coverage":
datetime.date(day=1, month=1, year=2000),
"quality_control_procedure":
data.quality_control_procedure.pk,
"inspire_themes":
[inspire_theme.pk for inspire_theme in inspire_themes],
"geographical_coverage": [
geographical_coverage.code
for geographical_coverage in geographical_coverages
],
"essential_variables": [],
}
return DATA_FOR_CLONE
def test_list_provider_json_filter_component(self):
metrics = base.RequirementFactory.create_metrics(self.creator)
romania = base.CountryFactory(code="RO")
# Create 4 components
first_component = base.ComponentFactory(name="First component")
second_component = base.ComponentFactory(name="Second component")
common_component = base.ComponentFactory(name="Common component")
other_component = base.ComponentFactory(name="Other component")
# Create data provider
dpr1 = base.DataProviderRelationFactory(
created_by=self.creator,
data__created_by=self.creator,
provider__name="First provider",
provider__created_by=self.creator,
provider__countries=[romania],
)
requirement1 = base.RequirementFactory(created_by=self.creator,
**metrics)
data_req1 = base.DataRequirementFactory(
created_by=self.creator,
data=dpr1.data,
requirement=requirement1,
)
# Associate it with first and common components
prod_req1 = base.ProductRequirementFactory(
created_by=self.creator,
requirement=requirement1,
product__component=first_component,
)
base.ProductRequirementFactory(
created_by=self.creator,
requirement=requirement1,
product__component=common_component,
)
# Create a second data provider
dpr2 = base.DataProviderRelationFactory(
created_by=self.creator,
data__created_by=self.creator,
provider__name="Second provider",
provider__created_by=self.creator,
provider__countries=[romania],
)
requirement2 = base.RequirementFactory(created_by=self.creator,
**metrics)
base.DataRequirementFactory(
created_by=self.creator,
data=dpr2.data,
requirement=requirement2,
)
# Associate it with second and common components
base.ProductRequirementFactory(
created_by=self.creator,
requirement=requirement2,
product__component=second_component,
)
base.ProductRequirementFactory(
created_by=self.creator,
requirement=requirement2,
product__component=common_component,
)
# Create a third data provider
dpr3 = base.DataProviderRelationFactory(
created_by=self.creator,
data__created_by=self.creator,
provider__name="Third provider",
provider__created_by=self.creator,
provider__countries=[romania],
)
requirement3 = base.RequirementFactory(created_by=self.creator,
**metrics)
base.DataRequirementFactory(
created_by=self.creator,
data=dpr3.data,
requirement=requirement3,
)
# Associate it with other component
base.ProductRequirementFactory(
created_by=self.creator,
requirement=requirement3,
product__component=other_component,
)
# Filter by component (First component)
resp = self.client.get(reverse("provider:json"),
{"component": "First component"})
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIs(data["recordsTotal"], 3)
self.assertIs(data["recordsFiltered"], 1)
# Filter by component (Second component)
resp = self.client.get(reverse("provider:json"),
{"component": "Second component"})
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIs(data["recordsTotal"], 3)
self.assertIs(data["recordsFiltered"], 1)
# Filter by component (Common component)
resp = self.client.get(reverse("provider:json"),
{"component": "Common component"})
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIs(data["recordsTotal"], 3)
self.assertIs(data["recordsFiltered"], 2)
objs_to_soft_delete = [
dpr1.provider,
dpr1,
dpr1.data,
data_req1,
requirement1,
prod_req1,
prod_req1.product,
]
# Soft delete intermediate objects
for obj in objs_to_soft_delete:
with soft_deleted(obj):
resp = self.client.get(reverse("provider:json"),
{"component": "First component"})
self.assertEqual(resp.status_code, 200)
data = resp.json()
# No records are filtered
self.assertIs(data["recordsFiltered"], 0)
def setUp(self):
super().setUp()
update_frequency = base.UpdateFrequencyFactory()
area = base.AreaFactory()
status = base.StatusFactory()
timeliness = base.TimelinessFactory()
data_policy = base.DataPolicyFactory()
data_type = base.DataTypeFactory()
data_format = base.DataFormatFactory()
quality_control_procedure = base.QualityControlProcedureFactory()
inspire_themes = [
base.InspireThemeFactory(),
base.InspireThemeFactory()
]
essential_variables = [
base.EssentialVariableFactory(),
base.EssentialVariableFactory(),
base.EssentialVariableFactory(),
]
geographical_coverages = [base.CountryFactory(code="T3")]
dissemination = base.DisseminationFactory()
self._DATA = {
"name":
"TEST data",
"note":
"TEST note",
"update_frequency":
update_frequency.pk,
"area":
area.pk,
"status":
status.pk,
"timeliness":
timeliness.pk,
"data_policy":
data_policy.pk,
"data_type":
data_type.pk,
"data_format":
data_format.pk,
"quality_control_procedure":
quality_control_procedure.pk,
"inspire_themes":
[inspire_theme.pk for inspire_theme in inspire_themes],
"start_time_coverage":
datetime.date(day=1, month=1, year=2000),
"end_time_coverage":
datetime.date(day=1, month=1, year=2000),
"essential_variables": [
essential_variable.pk
for essential_variable in essential_variables
],
"geographical_coverage": [
geographical_coverage.code
for geographical_coverage in geographical_coverages
],
"dissemination":
dissemination.pk,
}
self.creator = base.UserFactory(username="******")
self.client.force_login(self.creator)
with open(os.devnull, "w") as f:
call_command("search_index", "--rebuild", "-f", stdout=f)
