def setUpTestData(cls):
cls.user = UserFactory(username='******', email='*****@*****.**')
cls.user.set_password('admin')
cls.user.is_superuser = True
cls.user.is_staff = True
cls.user.save()
cls.classification = ClassificationFactory(name='Auto')
cls.product = ProductFactory(name='Kiwi',
classification=cls.classification)
cls.product_version = VersionFactory(value='0.1', product=cls.product)
cls.plan_type = PlanTypeFactory()
cls.test_plan = TestPlanFactory(name='another test plan for testing',
product_version=cls.product_version,
owner=cls.user,
author=cls.user,
product=cls.product,
type=cls.plan_type)
# add TestCases to plan with status CONFIRMED
for i in range(5):
case = TestCaseFactory(
plan=[cls.test_plan],
case_status=TestCaseStatus.objects.get(name='CONFIRMED'))
TestCaseTextFactory(case=case)
def setUpTestData(cls):
cls.post_data = {"description": "test"}
super().setUpTestData()
cls.plan_name = "TestNewTestPlanViewPermissions"
cls.product = ProductFactory()
cls.product_version = VersionFactory(product=cls.product)
cls.plan_type = PlanTypeFactory()
cls.test_plan = TestPlanFactory()
user_should_have_perm(cls.tester, perm="testplans.view_testplan")
cls.post_data.update( # pylint: disable=objects-update-used
{
"author": cls.tester.pk,
"product": cls.product.pk,
"product_version": cls.product_version.pk,
"type": cls.plan_type.pk,
"name": cls.plan_name,
"email_settings-0-auto_to_plan_author": "on",
"email_settings-0-auto_to_case_owner": "on",
"email_settings-0-auto_to_case_default_tester": "on",
"email_settings-0-notify_on_case_update": "on",
"email_settings-0-notify_on_plan_update": "on",
"email_settings-0-id": cls.test_plan.emailing.pk,
"email_settings-TOTAL_FORMS": "1",
"email_settings-INITIAL_FORMS": "1",
"email_settings-MIN_NUM_FORMS": "0",
"email_settings-MAX_NUM_FORMS": "1",
"is_active": True,
}
)
def test_product_delete_with_test_plan_wo_email_settings(self):
"""
A test to demonstrate Issue #181.
Steps to reproduce:
1) Create a new Product
2) Create a new Test Plan for Product
3) DON'T edit the Test Plan
4) Delete the Product
Expected results:
0) No errors
1) Product is deleted
2) Test Plan is deleted
"""
# setup
product = ProductFactory(name='Something to delete')
product_version = VersionFactory(value='0.1', product=product)
plan_type = PlanTypeFactory()
# create Test Plan via the UI by sending a POST request to the view
previous_plans_count = TestPlan.objects.count()
test_plan_name = 'Test plan for the new product'
response = self.c.post(reverse('plans-new'), {
'name': test_plan_name,
'product': product.pk,
'product_version': product_version.pk,
'type': plan_type.pk,
},
follow=True)
self.assertEqual(HTTPStatus.OK, response.status_code)
# verify test plan was created
self.assertTrue(test_plan_name in str(
response.content, encoding=settings.DEFAULT_CHARSET))
self.assertEqual(previous_plans_count + 1, TestPlan.objects.count())
# now delete the product
admin_delete_url = "admin:%s_%s_delete" % (product._meta.app_label,
product._meta.model_name)
location = reverse(admin_delete_url, args=[product.pk])
response = self.c.get(location)
self.assertEqual(HTTPStatus.OK, response.status_code)
self.assertTrue('Are you sure you want to delete the product "%s"' %
product.name in str(response.content,
encoding=settings.DEFAULT_CHARSET))
self.assertTrue("Yes, I'm sure" in str(
response.content, encoding=settings.DEFAULT_CHARSET))
# confirm that we're sure we want to delete it
response = self.c.post(location, {'post': 'yes'})
self.assertEqual(302, response.status_code)
self.assertTrue('/admin/%s/%s/' %
(product._meta.app_label,
product._meta.model_name) in response['Location'])
# verify everything has been deleted
self.assertFalse(Product.objects.filter(pk=product.pk).exists())
self.assertFalse(
Version.objects.filter(pk=product_version.pk).exists())
self.assertEqual(previous_plans_count, TestPlan.objects.count())
def setUpTestData(cls):
super().setUpTestData()
user_should_have_perm(cls.tester, perm="testplans.change_testplan")
user_should_have_perm(cls.tester, perm="testplans.view_testplan")
cls.product = ProductFactory()
cls.product_version = VersionFactory(product=cls.product)
cls.test_plan_type = PlanTypeFactory()
cls.test_plan_1 = TestPlanFactory()
cls.testplan_edit_url = reverse("plan-edit", args=[cls.test_plan_1.pk])
cls.testplan_edit_data = {
"author": cls.tester.pk,
"product": cls.product.pk,
"product_version": cls.product_version.pk,
"type": cls.test_plan_type.pk,
"name": cls.test_plan_1.name,
"email_settings-0-auto_to_plan_author": "on",
"email_settings-0-auto_to_case_owner": "on",
"email_settings-0-auto_to_case_default_tester": "on",
"email_settings-0-notify_on_case_update": "on",
"email_settings-0-notify_on_plan_update": "on",
"email_settings-0-id": cls.test_plan_1.emailing.pk,
"email_settings-TOTAL_FORMS": "1",
"email_settings-INITIAL_FORMS": "1",
"email_settings-MIN_NUM_FORMS": "0",
"email_settings-MAX_NUM_FORMS": "1",
"is_active": True,
}
def test_create_plan_with_different_user(self):
product = ProductFactory()
version = VersionFactory(product=product)
plan_type = PlanTypeFactory()
user = UserFactory()
params = {
"product": product.pk,
"product_version": version.pk,
"name": "test plan",
"type": plan_type.pk,
"text": "Testing TCMS",
"parent": None,
"author": user.pk,
}
result = self.rpc_client.TestPlan.create(params)
self.assertIn("id", result)
self.assertEqual(params["name"], result["name"])
self.assertEqual(params["text"], result["text"])
self.assertIn("create_date", result)
self.assertTrue(result["is_active"])
self.assertIn("extra_link", result)
self.assertEqual(params["product_version"], result["product_version"])
self.assertEqual(params["product"], result["product"])
self.assertEqual(user.pk, result["author"])
self.assertEqual(params["type"], result["type"])
self.assertEqual(params["parent"], result["parent"])
def setUpTestData(cls):
super().setUpTestData()
user_should_have_perm(cls.tester, perm='testplans.change_testplan')
cls.product = ProductFactory()
cls.product_version = VersionFactory(product=cls.product)
cls.test_plan_type = PlanTypeFactory()
cls.test_plan_1 = TestPlanFactory()
cls.testplan_edit_url = reverse('plan-edit', args=[cls.test_plan_1.pk])
cls.testplan_edit_data = {
'author': cls.tester.pk,
'product': cls.product.pk,
'product_version': cls.product_version.pk,
'type': cls.test_plan_type.pk,
'name': cls.test_plan_1.name,
'email_settings-0-auto_to_plan_author': 'on',
'email_settings-0-auto_to_case_owner': 'on',
'email_settings-0-auto_to_case_default_tester': 'on',
'email_settings-0-notify_on_case_update': 'on',
'email_settings-0-notify_on_plan_update': 'on',
'email_settings-0-id': cls.test_plan_1.emailing.pk,
'email_settings-TOTAL_FORMS': '1',
'email_settings-INITIAL_FORMS': '1',
'email_settings-MIN_NUM_FORMS': '0',
'email_settings-MAX_NUM_FORMS': '1',
'is_active': True,
}
def setUpTestData(cls):
cls.user = UserFactory(username="******", email="*****@*****.**")
cls.user.set_password("admin")
cls.user.is_superuser = True
cls.user.is_staff = True
cls.user.save()
cls.classification = ClassificationFactory(name="Auto")
cls.product = ProductFactory(name="Kiwi",
classification=cls.classification)
cls.product_version = VersionFactory(value="0.1", product=cls.product)
cls.plan_type = PlanTypeFactory()
cls.test_plan = TestPlanFactory(
name="another test plan for testing",
product_version=cls.product_version,
author=cls.user,
product=cls.product,
type=cls.plan_type,
)
# add TestCases to plan with status CONFIRMED
for _i in range(5):
TestCaseFactory(
plan=[cls.test_plan],
case_status=TestCaseStatus.objects.get(name="CONFIRMED"),
)
# also add a few PROPOSED TestCases
for _i in range(3):
TestCaseFactory(plan=[cls.test_plan])
cls.plan_id = cls.test_plan.pk
cls.child_plan = TestPlanFactory(parent=cls.test_plan)
def setUpTestData(cls):
super().setUpTestData()
cls.plan_name = "TestNewTestPlanView"
cls.product = ProductFactory()
cls.product_version = VersionFactory(product=cls.product)
cls.plan_type = PlanTypeFactory()
cls.test_plan = TestPlanFactory()
user_should_have_perm(cls.tester, perm="testplans.add_testplan")
user_should_have_perm(cls.tester, perm="testplans.view_testplan")
cls.location = reverse("plans-new")
cls.request = {
"author": cls.tester.pk,
"product": cls.product.pk,
"product_version": cls.product_version.pk,
"type": cls.plan_type.pk,
"name": cls.plan_name,
"email_settings-0-auto_to_plan_author": "on",
"email_settings-0-auto_to_case_owner": "on",
"email_settings-0-auto_to_case_default_tester": "on",
"email_settings-0-notify_on_case_update": "on",
"email_settings-0-notify_on_plan_update": "on",
"email_settings-0-id": cls.test_plan.emailing.pk,
"email_settings-TOTAL_FORMS": "1",
"email_settings-INITIAL_FORMS": "1",
"email_settings-MIN_NUM_FORMS": "0",
"email_settings-MAX_NUM_FORMS": "1",
"is_active": True,
}
def test_product_delete_with_test_plan_wo_email_settings(self):
"""
A test to demonstrate Issue #181.
Steps to reproduce:
1) Create a new Product
2) Create a new Test Plan for Product
3) DON'T edit the Test Plan
4) Delete the Product
Expected results:
0) No errors
1) Product is deleted
2) Test Plan is deleted
"""
# setup
product = ProductFactory(name="Something to delete")
product_version = VersionFactory(value="0.1", product=product)
plan_type = PlanTypeFactory()
previous_plans_count = TestPlan.objects.count()
TestPlan.objects.create(
name="Test plan for the new product",
author=self.user,
product=product,
product_version=product_version,
type=plan_type,
)
# verify TP was created
self.assertEqual(previous_plans_count + 1, TestPlan.objects.count())
# make sure there are no email settings
TestPlanEmailSettings.objects.all().delete()
# now delete the product
# pylint: disable=no-member
admin_delete_url = (
f"admin:{product._meta.app_label}_{product._meta.model_name}_delete"
)
location = reverse(admin_delete_url, args=[product.pk])
response = self.c.get(location)
self.assertContains(response, product.name)
self.assertContains(response, _("Yes, I'm sure"))
# confirm that we're sure we want to delete it
response = self.c.post(location, {"post": "yes"})
self.assertEqual(302, response.status_code)
self.assertIn(
f"/admin/{product._meta.app_label}/{product._meta.model_name}/",
response["Location"],
)
# verify everything has been deleted
self.assertFalse(Product.objects.filter(pk=product.pk).exists())
self.assertFalse(Version.objects.filter(pk=product_version.pk).exists())
self.assertEqual(previous_plans_count, TestPlan.objects.count())
def test_create_plan_with_empty_required_field(self):
product = ProductFactory()
version = VersionFactory(product=product)
plan_type = PlanTypeFactory()
with self.assertRaisesRegex(XmlRPCFault, 'This field is required.'):
self.rpc_client.TestPlan.create({
'product': product.pk,
'product_version': version.pk,
'name': '',
'type': plan_type.pk,
'text': 'Testing TCMS',
'parent': None,
})
def test_create_plan_with_empty_required_field(self):
product = ProductFactory()
version = VersionFactory(product=product)
plan_type = PlanTypeFactory()
with self.assertRaisesRegex(XmlRPCFault, "This field is required."):
self.rpc_client.TestPlan.create({
"product": product.pk,
"product_version": version.pk,
"name": "",
"type": plan_type.pk,
"text": "Testing TCMS",
"parent": None,
})
def _fixture_setup(self):
super()._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory(product=self.product)
self.plan_type = PlanTypeFactory()
self.params = {
"product": self.product.pk,
"product_version": self.version.pk,
"name": "Testplan foobar",
"type": self.plan_type.pk,
"text": "Testing TCMS",
"parent": None,
}
def _fixture_setup(self):
super()._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory(product=self.product)
self.plan_type = PlanTypeFactory()
self.params = {
'product': self.product.pk,
'product_version': self.version.pk,
'name': 'Testplan foobar',
'type': self.plan_type.pk,
'text': 'Testing TCMS',
'parent': None,
}
def _fixture_setup(self):
super(TestFilter, self)._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory(product=self.product)
self.tester = UserFactory()
self.plan_type = PlanTypeFactory(name='manual smoking')
self.plan_1 = TestPlanFactory(product_version=self.version,
product=self.product,
author=self.tester,
type=self.plan_type)
self.plan_2 = TestPlanFactory(product_version=self.version,
product=self.product,
author=self.tester,
type=self.plan_type)
def test_user_with_default_perms_can_create_testplan_and_set_env_group(self):
# test for https://github.com/kiwitcms/Kiwi/issues/73
url = reverse('plans-new')
response = self.client.post(
url,
{
'name': 'TP for Issue #73',
'product': self.product.pk,
'product_version': self.product_version.pk,
'type': PlanTypeFactory().pk,
'env_group': self.env_group.pk,
},
follow=True,
)
self.assertEqual(HTTPStatus.OK, response.status_code)
self.assertContains(response, ">%s</a>" % self.env_group.name)
def setUpTestData(cls):
cls.user = UserFactory(username='******', email='*****@*****.**')
cls.user.set_password('admin')
cls.user.is_superuser = True
cls.user.save()
cls.c = Client()
cls.c.login( # nosec:B106:hardcoded_password_funcarg
username='******',
password='******')
cls.classification = ClassificationFactory(name='Auto')
cls.product = ProductFactory(name='Kiwi',
classification=cls.classification)
cls.product_version = VersionFactory(value='0.1', product=cls.product)
cls.plan_type = PlanTypeFactory()
cls.test_plan = TestPlanFactory(name='Test plan for testing exports',
product_version=cls.product_version,
owner=cls.user,
author=cls.user,
product=cls.product,
type=cls.plan_type)
# create test cases into the test plan
cls.cases = []
for i in range(10):
case = TestCaseFactory(summary='test_case_number_%d' % i,
author=cls.user,
default_tester=None,
reviewer=cls.user,
plan=[cls.test_plan])
tag = TagFactory(name='tag_for_%s' % case.summary)
component = ComponentFactory(name='component_for_%s' %
case.summary)
case.add_tag(tag)
case.add_component(component)
if i % 2 == 0:
tag = TagFactory(name='second_tag_for_%s' % case.summary)
component = ComponentFactory(name='second_component_for_%s' %
case.summary)
case.add_tag(tag)
case.add_component(component)
cls.cases.append(case)
def _fixture_setup(self):
super()._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory(product=self.product)
self.tester = UserFactory()
self.plan_type = PlanTypeFactory()
self.plan_1 = TestPlanFactory(
product_version=self.version,
product=self.product,
author=self.tester,
type=self.plan_type,
)
self.plan_2 = TestPlanFactory(
product_version=self.version,
product=self.product,
author=self.tester,
type=self.plan_type,
)
def _fixture_setup(self):
super(TestUpdate, self)._fixture_setup()
self.env_group_1 = EnvGroupFactory()
self.env_group_2 = EnvGroupFactory()
self.product = ProductFactory()
self.version = VersionFactory(product=self.product)
self.tester = UserFactory()
self.plan_type = PlanTypeFactory(name='manual smoking')
self.plan_1 = TestPlanFactory(product_version=self.version,
product=self.product,
author=self.tester,
type=self.plan_type,
env_group=(self.env_group_1, ))
self.plan_2 = TestPlanFactory(product_version=self.version,
product=self.product,
author=self.tester,
type=self.plan_type,
env_group=(self.env_group_1, ))
def setUpTestData(cls):
cls.user = UserFactory(username='******', email='*****@*****.**')
cls.user.set_password('admin')
cls.user.is_superuser = True
cls.user.save()
cls.c = Client()
cls.c.login(username='******', password='******')
cls.classification = ClassificationFactory(name='Auto')
cls.product = ProductFactory(name='Kiwi',
classification=cls.classification)
cls.product_version = VersionFactory(value='0.1', product=cls.product)
cls.plan_type = PlanTypeFactory()
cls.test_plan = TestPlanFactory(name='another test plan for testing',
product_version=cls.product_version,
owner=cls.user,
author=cls.user,
product=cls.product,
type=cls.plan_type)
cls.plan_id = cls.test_plan.pk
cls.child_plan = TestPlanFactory(parent=cls.test_plan)
def test_create_plan_with_different_user(self):
product = ProductFactory()
version = VersionFactory(product=product)
plan_type = PlanTypeFactory()
user = UserFactory()
params = {
'product': product.pk,
'product_version': version.pk,
'name': 'test plan',
'type': plan_type.pk,
'text': 'Testing TCMS',
'parent': None,
'author': user.pk
}
result = self.rpc_client.TestPlan.create(params)
self.assertEqual(params['product'], result['product_id'])
self.assertEqual(params['product_version'], result['product_version_id'])
self.assertEqual(params['name'], result['name'])
self.assertEqual(params['type'], result['type_id'])
self.assertEqual(params['text'], result['text'])
self.assertEqual(params['parent'], result['parent'])
self.assertEqual(user.username, result['author'])
self.assertEqual(user.pk, result['author_id'])
def _fixture_setup(self):
super(PlanTypeMethods, self)._fixture_setup()
self.plan_type = PlanTypeFactory(name='xmlrpc plan type',
description='')
def _fixture_setup(self):
super()._fixture_setup()
self.plan_type = PlanTypeFactory(name="xmlrpc plan type", description="")
