def test_list_data_json_filter(self):
base.DataFactory(name="Test data", created_by=self.creator)
base.DataFactory(name="Other data", created_by=self.creator)
resp = self.client.get(reverse("data: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_list_data_json_filter(self):
base.DataFactory(name='Test data', created_by=self.creator)
base.DataFactory(name='Other data', created_by=self.creator)
resp = self.client.get(reverse('data: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_transition_existent_state_no_transition(self):
self.login_creator()
data = base.DataFactory(name="Test data", created_by=self.creator)
provider = base.DataProviderFactory(name="Test provider",
created_by=self.creator)
base.DataProviderRelationFactory(data=data,
created_by=self.creator,
provider=provider)
items = [data, provider]
response = self.client.post(
reverse(
"data:transition",
kwargs={
"source": "draft",
"target": "valid",
"pk": data.pk
},
))
self.assertEqual(response.status_code, 404)
for item in items:
getattr(item, "refresh_from_db")()
self.assertEqual((getattr(item, "state")).name, "draft")
def test_transition_changes_requested_feedback(self):
self.erase_logging_file()
self.login_creator()
metrics = base.RequirementFactory.create_metrics(self.creator,
state="ready")
requirement = base.RequirementFactory(name="Test requirement",
state="ready",
created_by=self.creator,
**metrics)
data = base.DataFactory(name="Test data", created_by=self.creator)
data_requirement = base.DataRequirementFactory(data=data,
state="ready",
created_by=self.creator,
requirement=requirement)
items = [requirement, data_requirement]
for item in items:
self.assertEqual((getattr(item, "state")).name, "ready")
self.client.force_login(self.other_user)
self.client.post(
reverse(
"requirement:transition",
kwargs={
"source": "ready",
"target": "changes",
"pk": requirement.pk
},
),
{"feedback": "this is a feedback test"},
)
getattr(requirement, "refresh_from_db")()
self.assertEqual(requirement.state, "changes")
self.assertEqual(requirement.feedback, "this is a feedback test")
def test_transition_inexistent_state(self):
self.login_creator()
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(name="Test requirement",
created_by=self.creator,
**metrics)
data = base.DataFactory(name="Test data", created_by=self.creator)
data_requirement = base.DataRequirementFactory(data=data,
created_by=self.creator,
requirement=requirement)
provider = base.DataProviderFactory(name="Test provider",
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(
data=data, created_by=self.creator, provider=provider)
items = [requirement, data, data_requirement, provider, data_provider]
response = self.client.post(
reverse(
"requirement:transition",
kwargs={
"source": "draft",
"target": "nosuchstate",
"pk": requirement.pk,
},
))
self.assertEqual(response.status_code, 404)
for item in items:
getattr(item, "refresh_from_db")()
self.assertEqual((getattr(item, "state")).name, "draft")
def test_transition_with_draft_data(self):
self.erase_logging_file()
self.login_creator()
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(name="Test requirement",
created_by=self.creator,
**metrics)
data = base.DataFactory(name="Test data",
created_by=self.creator,
update_frequency=None)
data_requirement = base.DataRequirementFactory(data=data,
created_by=self.creator,
requirement=requirement)
items = [requirement, data_requirement]
for item in items:
self.assertEqual((getattr(item, "state")).name, "draft")
self.client.force_login(self.creator)
response = self.client.get(
reverse(
"requirement:transition",
kwargs={
"source": "draft",
"target": "ready",
"pk": requirement.pk
},
))
self.assertTrue(response.status_code, 200)
def test_provider_relation_edit(self):
self.login_creator()
data_object = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data_object,
created_by=self.creator,
)
data = self._DATA
data.pop("data")
data.pop("provider")
resp = self.client.post(
reverse(
"data:provider:edit",
kwargs={
"group_pk": provider_relation.data.pk,
"pk": provider_relation.pk,
},
),
data,
)
self.assertEqual(resp.status_code, 302)
data["data"] = provider_relation.data.pk
data["provider"] = provider_relation.provider.pk
self.check_single_object(models.DataProviderRelation, data)
def test_transition_with_draft_data(self):
self.erase_logging_file()
self.login_creator()
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(name='Test requirement',
created_by=self.creator,
**metrics)
data = base.DataFactory(name='Test data',
created_by=self.creator,
update_frequency=None)
data_requirement = base.DataRequirementFactory(data=data,
created_by=self.creator,
requirement=requirement)
items = ([requirement, data_requirement] + list(metrics.values()))
for item in items:
self.assertEqual((getattr(item, 'state')).name, 'draft')
self.client.force_login(self.creator)
response = self.client.get(
reverse('requirement:transition',
kwargs={
'source': 'draft',
'target': 'ready',
'pk': requirement.pk
}))
self.assertTrue(response.status_code, 200)
def test_transition_changes_requested_feedback(self):
self.erase_logging_file()
self.login_creator()
data = base.DataFactory(name="Test data",
state="ready",
created_by=self.creator)
provider = base.DataProviderFactory(name="Test provider",
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(
data=data,
state="ready",
created_by=self.creator,
provider=provider)
items = [data, data_provider]
for item in items:
self.assertEqual((getattr(item, "state")).name, "ready")
self.client.force_login(self.other_user)
self.client.post(
reverse(
"data:transition",
kwargs={
"source": "ready",
"target": "changes",
"pk": data.pk
},
),
{"feedback": "this is a feedback test"},
)
getattr(data, "refresh_from_db")()
self.assertEqual(data.state, "changes")
self.assertEqual(data.feedback, "this is a feedback test")
def test_data_requirement_edit(self):
self.login_creator()
data_object = base.DataFactory(created_by=self.creator)
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(created_by=self.creator,
**metrics)
data_requirement = base.DataRequirementFactory(
data=data_object,
requirement=requirement,
created_by=self.creator,
)
data = self._DATA
data.pop("data")
data.pop("requirement")
resp = self.client.post(
reverse(
"requirement:data:edit",
kwargs={
"requirement_pk": data_requirement.requirement.pk,
"pk": data_requirement.pk,
},
),
data,
)
self.assertEqual(resp.status_code, 302)
data["data"] = data_requirement.data.pk
data["requirement"] = data_requirement.requirement.pk
self.check_single_object(models.DataRequirement, data)
def test_transition_existent_state_no_transition(self):
self.login_creator()
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(name='Test requirement',
created_by=self.creator,
**metrics)
data = base.DataFactory(name='Test data', created_by=self.creator)
data_requirement = base.DataRequirementFactory(data=data,
created_by=self.creator,
requirement=requirement)
provider = base.DataProviderFactory(name='Test provider',
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(
data=data, created_by=self.creator, provider=provider)
items = ([requirement, data_requirement] + list(metrics.values()))
response = self.client.post(
reverse('requirement:transition',
kwargs={
'source': 'draft',
'target': 'valid',
'pk': requirement.pk
}))
self.assertEqual(response.status_code, 404)
for item in items:
getattr(item, 'refresh_from_db')()
self.assertEqual((getattr(item, 'state')).name, 'draft')
def test_user_records(self):
self.login_creator()
user_data = base.DataFactory(created_by=self.creator)
user_provider = base.DataProviderFactory(created_by=self.creator)
user_provider_rel = base.DataProviderRelationFactory(
created_by=self.creator,
data=user_data,
provider=user_provider,
)
link_table_name = 'Links between Data and Data Providers'
resp = self.client.get(
reverse('user_records', kwargs={"pk": self.creator.id}))
self.assertEqual(resp.status_code, 200)
self.assertQuerysetEqual(resp.context['data_list'],
['<Data: test Data>'])
self.assertEqual(resp.context['providers_list'][0].created_by,
self.creator)
self.assertEqual(len(resp.context['provider_relations']), 1)
self.assertEqual(len(resp.context['requirements_list']), 0)
self.assertEqual(resp.context['provider_relations'][0].data, user_data)
self.assertEqual(resp.context['provider_relations'][0].provider,
user_provider_rel.provider)
self.assertIn(link_table_name, str(resp.content, 'utf-8'))
def test_post_add_with_clone_ready_errors(self):
data = base.DataFactory(created_by=self.creator)
self._create_clone_data(data)
resp = self.client.post(reverse('data:add') + '?ready&pk=' + str(data.pk),
{})
self.assertEqual(resp.status_code, 200)
self.check_required_errors(resp, self.errors)
def test_post_add_clone_without_ready(self):
data = base.DataFactory(created_by=self.creator)
cloned_data = self._create_clone_data(data)
resp = self.client.post(reverse('data:add') + '?pk=' + str(data.pk),
cloned_data)
self.assertEqual(resp.status_code, 302)
self.check_object(models.Data.objects.last(), cloned_data)
def test_detail_data(self):
self.erase_logging_file()
data = base.DataFactory(created_by=self.creator)
resp = self.client.get(reverse('data:detail',
kwargs={'pk': data.pk}))
self.assertEqual(resp.context['data'], data)
self.logging()
def test_list_data_json(self):
base.DataFactory(created_by=self.creator)
resp = self.client.get(reverse('data:json'))
self.assertEqual(resp.status_code, 200)
data = resp.json()
self.assertIsNot(data['recordsTotal'], 0)
self.assertEqual(data['recordsTotal'], data['recordsFiltered'])
def test_delete_data(self):
self.login_creator()
self.erase_logging_file()
data = base.DataFactory(created_by=self.creator)
resp = self.client.post(reverse('data:delete', kwargs={'pk': data.pk}))
self.assertEqual(resp.status_code, 302)
self.check_single_object_deleted(models.Data)
self.check_objects_are_soft_deleted(models.Data, DataDoc)
self.logging()
def test_get_add_with_clone(self):
self.erase_logging_file()
data = base.DataFactory(created_by=self.creator)
resp = self.client.get(reverse('data:add') + '?ready&pk=' + str(data.pk),
{})
self.assertEqual(resp.status_code, 200)
form_data = [ value for field, value in resp.context['form'].initial.items()]
self.assertTrue(form_data)
self.logging()
def test_provider_relation_add_required_fields(self):
data = {}
data_factory = base.DataFactory(created_by=self.creator)
errors_data = self.errors.copy()
errors_data.pop('data')
resp = self.client.post(
reverse('data:provider:add', kwargs={'group_pk': data_factory.pk}),
data)
self.check_required_errors(resp, errors_data)
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_delete_data_provider_non_network_related_objects(self):
self.login_creator()
provider = base.DataProviderFactory(is_network=False,
created_by=self.creator)
data = base.DataFactory(created_by=self.creator)
base.DataProviderDetailsFactory(data_provider=provider,
created_by=self.creator)
base.DataProviderRelationFactory(provider=provider,
data=data,
created_by=self.creator)
self.client.post(
reverse("provider:delete_non_network", kwargs={"pk": provider.pk}))
self.check_objects_are_soft_deleted(models.DataProviderDetails)
self.check_objects_are_soft_deleted(models.DataProviderRelation)
def test_provider_relation_edit_not_auth(self):
data = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data,
created_by=self.creator,
)
self.check_user_redirect_all_methods(redirect_url=self.login_url,
url=reverse(
'data:provider:edit',
kwargs={
'group_pk': data.pk,
'pk': provider_relation.pk
}))
def test_delete_provider_relation_teammate(self):
data = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data,
created_by=self.creator,
)
self.check_permission_for_teammate(
method="GET",
url=reverse(
"data:provider:delete",
kwargs={"group_pk": data.pk, "pk": provider_relation.pk},
),
)
def test_provider_relation_delete_not_auth(self):
data = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data,
created_by=self.creator,
)
self.check_user_redirect_all_methods(
redirect_url=reverse("data:list"),
url=reverse(
"data:provider:delete",
kwargs={"group_pk": data.pk, "pk": provider_relation.pk},
),
)
def test_provider_relation_delete_auth(self):
data = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data,
created_by=self.creator,
)
self.check_authenticated_user_redirect_all_methods(
redirect_url=reverse('data:list'),
url=reverse('data:provider:delete',
kwargs={
'group_pk': data.pk,
'pk': provider_relation.pk
}))
def test_delete_provider_relation_teammate(self):
data = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data,
created_by=self.creator,
)
self.check_permission_for_teammate(method='GET',
url=reverse('data:provider:delete',
kwargs={
'group_pk':
data.pk,
'pk':
provider_relation.pk
}))
def test_get_provider_relation_edit(self):
self.login_creator()
data_object = base.DataFactory(created_by=self.creator)
provider = base.DataProviderFactory(created_by=self.creator)
provider_relation = base.DataProviderRelationFactory(
provider=provider,
data=data_object,
created_by=self.creator,
)
resp = self.client.get(
reverse('data:provider:edit',
kwargs={
'group_pk': provider_relation.data.pk,
'pk': provider_relation.pk
}))
self.assertEqual(resp.status_code, 200)
def test_delete_data_related_objects(self):
self.login_creator()
data = base.DataFactory(created_by=self.creator)
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(created_by=self.creator,
**metrics)
base.DataRequirementFactory(data=data,
requirement=requirement,
created_by=self.creator)
data_provider = base.DataProviderFactory(created_by=self.creator)
base.DataProviderRelationFactory(data=data,
provider=data_provider,
created_by=self.creator)
self.client.post(reverse('data:delete', kwargs={'pk': data.pk}))
self.check_objects_are_soft_deleted(models.DataRequirement)
self.check_objects_are_soft_deleted(models.DataProviderRelation)
def test_delete_requirement_related_objects(self):
self.login_creator()
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(name='Test requirement',
created_by=self.creator,
**metrics)
base.ProductRequirementFactory(requirement=requirement,
created_by=self.creator)
data = base.DataFactory(created_by=self.creator)
base.DataRequirementFactory(requirement=requirement,
data=data,
created_by=self.creator)
self.client.post(
reverse('requirement:delete', kwargs={'pk': requirement.pk}))
self.check_objects_are_soft_deleted(models.ProductRequirement)
self.check_objects_are_soft_deleted(models.DataRequirement)
def test_data_requirement_delete_auth_from_data_requirement(self):
data_object = base.DataFactory(created_by=self.creator)
metrics = base.RequirementFactory.create_metrics(self.creator)
requirement = base.RequirementFactory(created_by=self.creator,
**metrics)
data_requirement = base.DataRequirementFactory(
data=data_object,
requirement=requirement,
created_by=self.creator,
)
self.check_authenticated_user_redirect_all_methods(
redirect_url=reverse('requirement:list'),
url=reverse('requirement:data:delete',
kwargs={
'requirement_pk': data_requirement.pk,
'pk': data_requirement.pk
}))
