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_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_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_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_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_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_provider_relation_add_unique(self):
base.DataProviderRelationFactory(data=self.data,
provider=self.provider,
created_by=self.creator)
data = self._DATA
resp = self.client.post(
reverse('data:provider:add', kwargs={'group_pk': self.data.pk}),
data)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.context['form'].errors,
{'__all__': ['This relation already exists.']})
def test_provider_relation_add_unique(self):
base.DataProviderRelationFactory(
data=self.data, provider=self.provider, created_by=self.creator
)
data = self._DATA
resp = self.client.post(
reverse("data:provider:add", kwargs={"group_pk": self.data.pk}), data
)
self.assertEqual(resp.status_code, 200)
self.assertEqual(
resp.context["form"].errors, {"__all__": ["This relation already exists."]}
)
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_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_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(self):
self.login_creator()
data = {}
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.post(
reverse('data:provider:delete',
kwargs={
'group_pk': provider_relation.data.pk,
'pk': provider_relation.pk
}), data)
self.assertEqual(resp.status_code, 302)
self.check_single_object_deleted(models.DataProviderRelation)
def test_transition(self):
self.erase_logging_file()
self.login_creator()
data = base.DataFactory(name='Test data',
created_by=self.creator)
provider = base.DataProviderFactory(name='Test provider',
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(data=data,
created_by=self.creator,
provider=provider)
items = ([data, data_provider])
for item in items:
self.assertEqual((getattr(item, 'state')).name, 'draft')
transitions = [
{'source': 'draft', 'target': 'ready', 'user': self.creator},
{'source': 'ready', 'target': 'draft', 'user': self.creator},
{'source': 'draft', 'target': 'ready', 'user': self.creator},
{'source': 'ready', 'target': 'changes', 'user': self.other_user},
{'source': 'changes', 'target': 'draft', 'user': self.creator},
{'source': 'draft', 'target': 'ready', 'user': self.creator},
{'source': 'ready', 'target': 'valid', 'user': self.other_user},
{'source': 'ready', 'target': 'valid', 'user': self.creator},
]
for transition in transitions:
for item in items:
self.assertEqual((getattr(item, 'state')).name, transition['source'])
self.client.force_login(transition['user'])
response = self.client.post(
reverse('data:transition',
kwargs={'source': transition['source'],
'target': transition['target'],
'pk': data.pk}))
self.assertRedirects(response, reverse('data:detail',
kwargs={'pk': data.pk}))
for item in items:
getattr(item, 'refresh_from_db')()
self.assertEqual((getattr(item, 'state')).name, transition['target'])
if transition['target'] == 'valid':
for item in items:
item.state = transition['source']
item.save()
self.logging(check_username=False)
def test_get_provider_relation_delete(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:delete",
kwargs={
"group_pk": provider_relation.data.pk,
"pk": provider_relation.pk,
},
)
)
self.assertEqual(resp.status_code, 200)
def test_transition_with_draft_data(self):
self.erase_logging_file()
self.login_creator()
data = base.DataFactory(name='Test data',
created_by=self.creator)
provider = base.DataProviderFactory(name='Test provider',
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(data=data,
created_by=self.creator,
provider=provider)
items = ([data, data_provider])
for item in items:
self.assertEqual((getattr(item, 'state')).name, 'draft')
self.client.force_login(self.creator)
response = self.client.get(
reverse('data:transition',
kwargs={'source': 'draft',
'target': 'ready',
'pk': data.pk}))
self.assertTrue(response.status_code, 200)
def test_transition_inexistent_state(self):
self.login_creator()
data = base.DataFactory(name='Test data', created_by=self.creator)
provider = base.DataProviderFactory(name='Test provider',
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(
data=data, created_by=self.creator, provider=provider)
items = ([data, data_provider])
response = self.client.post(
reverse('data:transition',
kwargs={
'source': 'draft',
'target': 'nosuchstate',
'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_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()
data = base.DataFactory(name="Test data", created_by=self.creator)
provider = base.DataProviderFactory(name="Test provider",
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(
data=data, created_by=self.creator, provider=provider)
items = [data, data_provider]
for item in items:
self.assertEqual((getattr(item, "state")).name, "draft")
self.client.force_login(self.creator)
response = self.client.get(
reverse(
"data:transition",
kwargs={
"source": "draft",
"target": "ready",
"pk": data.pk
},
))
self.assertTrue(response.status_code, 200)
def test_transition(self):
self.erase_logging_file()
self.login_creator()
data = base.DataFactory(name="Test data", created_by=self.creator)
provider = base.DataProviderFactory(name="Test provider",
created_by=self.creator)
data_provider = base.DataProviderRelationFactory(
data=data, created_by=self.creator, provider=provider)
items = [data, data_provider]
for item in items:
self.assertEqual((getattr(item, "state")).name, "draft")
transitions = [
{
"source": "draft",
"target": "ready",
"user": self.creator
},
{
"source": "ready",
"target": "draft",
"user": self.creator
},
{
"source": "draft",
"target": "ready",
"user": self.creator
},
{
"source": "ready",
"target": "changes",
"user": self.other_user
},
{
"source": "changes",
"target": "draft",
"user": self.creator
},
{
"source": "draft",
"target": "ready",
"user": self.creator
},
{
"source": "ready",
"target": "valid",
"user": self.other_user
},
{
"source": "ready",
"target": "valid",
"user": self.creator
},
]
for transition in transitions:
for item in items:
self.assertEqual((getattr(item, "state")).name,
transition["source"])
self.client.force_login(transition["user"])
response = self.client.post(
reverse(
"data:transition",
kwargs={
"source": transition["source"],
"target": transition["target"],
"pk": data.pk,
},
))
self.assertRedirects(
response, reverse("data:detail", kwargs={"pk": data.pk}))
for item in items:
getattr(item, "refresh_from_db")()
self.assertEqual((getattr(item, "state")).name,
transition["target"])
if transition["target"] == "valid":
for item in items:
item.state = transition["source"]
item.save()
self.logging(check_username=False)
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)
