def setUpTestData(cls):
cls.product_name = 'StarCraft'
cls.versions = ['0.6', '0.7', '0.8', '0.9', '1.0']
cls.product = ProductFactory(name=cls.product_name)
cls.product_versions = [
VersionFactory(product=cls.product, value=version)
for version in cls.versions
]
def _fixture_setup(self):
super()._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory()
self.build = self.product.build.first()
self.plan = TestPlanFactory(author=self.api_user,
product=self.product,
product_version=self.version)
def _fixture_setup(self):
super(TestBuildGetRuns, self)._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory(value='0.1', product=self.product)
self.build = TestBuildFactory(product=self.product)
self.user = UserFactory()
self.test_run = TestRunFactory(manager=self.user, default_tester=None,
build=self.build)
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 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 setUpTestData(cls):
cls.product = ProductFactory()
cls.request = HttpRequest()
cls.info_objects = _InfoObjects(cls.request, cls.product.pk)
cls.category_one = CategoryFactory(product=cls.product)
cls.category_two = CategoryFactory(product=cls.product)
cls.category_three = CategoryFactory()
cls.component_one = ComponentFactory(product=cls.product)
cls.component_two = ComponentFactory(product=cls.product)
cls.component_three = ComponentFactory()
cls.user_one = UserFactory()
cls.user_two = UserFactory()
cls.version_one = VersionFactory(product=cls.product)
cls.version_two = VersionFactory()
def setUpTestData(cls):
cls.user = UserFactory(username='******')
cls.product_starcraft = ProductFactory(name='StarCraft')
cls.starcraft_version_0_1 = VersionFactory(value='0.1', product=cls.product_starcraft)
cls.starcraft_version_0_2 = VersionFactory(value='0.2', product=cls.product_starcraft)
cls.product_streetfighter = ProductFactory(name='StreetFighter')
cls.streetfighter_version_0_1 = VersionFactory(value='0.1', product=cls.product_streetfighter)
cls.plans = [
TestPlanFactory(name='StarCraft: Init',
product=cls.product_starcraft, product_version=cls.starcraft_version_0_1,
author=cls.user, owner=cls.user),
TestPlanFactory(name='StarCraft: Start',
product=cls.product_starcraft, product_version=cls.starcraft_version_0_2,
author=cls.user, owner=cls.user),
TestPlanFactory(name='StreetFighter',
product=cls.product_streetfighter,
product_version=cls.streetfighter_version_0_1,
author=cls.user, owner=cls.user),
]
def setUpTestData(cls):
cls.case_status_confirmed = TestCaseStatus.objects.get(
name='CONFIRMED')
cls.case_status_proposed = TestCaseStatus.objects.get(name='PROPOSED')
cls.product = ProductFactory(name='Kiwi')
cls.version = VersionFactory(value='0.1', product=cls.product)
cls.tester = User.objects.create_user(username='******',
email='*****@*****.**')
cls.tester.set_password('password')
cls.tester.save()
cls.plan = TestPlanFactory(author=cls.tester,
owner=cls.tester,
product=cls.product,
product_version=cls.version)
cls.case = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_1 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_2 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_3 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_4 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_5 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_6 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
def setUpTestData(cls):
cls.product = ProductFactory(name='StarCraft')
cls.starcraft_version_0_1 = VersionFactory(value='0.1', product=cls.product)
cls.components = [
ComponentFactory(name='application', product=cls.product,
initial_owner=None, initial_qa_contact=None),
ComponentFactory(name='database', product=cls.product,
initial_owner=None, initial_qa_contact=None),
ComponentFactory(name='documentation', product=cls.product,
initial_owner=None, initial_qa_contact=None),
]
def setUpTestData(cls):
super(TestEditRun, cls).setUpTestData()
user_should_have_perm(cls.tester, 'testruns.change_testrun')
cls.edit_url = reverse('testruns-edit', args=[cls.test_run.pk])
cls.new_product = ProductFactory(name='Nitrate Dev')
cls.new_build = BuildFactory(name='FastTest', product=cls.new_product)
cls.new_version = VersionFactory(value='dev0.1',
product=cls.new_product)
cls.intern = UserFactory(username='******', email='*****@*****.**')
def setUpTestData(cls):
super(TestPlanEnvironmentGroupTests, cls).setUpTestData()
cls.product = ProductFactory()
cls.product_version = VersionFactory(product=cls.product)
cls.env_group = EnvGroupFactory()
cls.new_env_group = EnvGroupFactory(name='Laptop hardware')
cls.tester = UserFactory()
cls.tester.set_password('password')
initiate_user_with_default_setups(cls.tester)
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.staff = UserFactory(username='******', email='*****@*****.**')
self.product = ProductFactory(name='Nitrate')
self.version = VersionFactory(value='0.1', product=self.product)
self.build = self.product.build.first()
self.plan = TestPlanFactory(author=self.api_user, product=self.product)
self.test_run = TestRunFactory(product_version=self.version, build=self.build,
default_tester=None, plan=self.plan)
self.status = TestExecutionStatus.objects.filter(weight=0).first()
self.case = TestCaseFactory(author=self.api_user, default_tester=None, plan=[self.plan])
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 setUpTestData(cls):
super().setUpTestData()
cls.case_status_confirmed = TestCaseStatus.objects.get(
name='CONFIRMED')
cls.case_status_proposed = TestCaseStatus.objects.get(name='PROPOSED')
cls.product = ProductFactory(name='Kiwi')
cls.version = VersionFactory(value='0.1', product=cls.product)
cls.plan = TestPlanFactory(author=cls.tester,
owner=cls.tester,
product=cls.product,
product_version=cls.version)
cls.case = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_1 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_2 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_3 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_4 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_5 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
cls.case_6 = TestCaseFactory(author=cls.tester,
default_tester=None,
reviewer=cls.tester,
case_status=cls.case_status_confirmed,
plan=[cls.plan])
def setUpTestData(cls):
cls.tester = UserFactory(username='******')
cls.product = ProductFactory(name='StarCraft')
cls.version = VersionFactory(value='0.1', product=cls.product)
cls.plan = TestPlanFactory(name='Test product.get_cases',
owner=cls.tester, author=cls.tester,
product=cls.product,
product_version=cls.version)
cls.case_category = TestCaseCategoryFactory(product=cls.product)
cls.cases_count = 10
cls.cases = [TestCaseFactory(category=cls.case_category, author=cls.tester,
reviewer=cls.tester, default_tester=None,
plan=[cls.plan])
for i in range(cls.cases_count)]
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()
self.build = self.product.build.first()
self.plan = TestPlanFactory(product=self.product,
product_version=self.version)
self.test_run_fields = {
'plan': self.plan.pk,
'build': self.build.pk,
'summary': 'TR created',
'manager': UserFactory().pk
}
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.build = BuildFactory(version=self.version)
self.plan = TestPlanFactory(product=self.product,
product_version=self.version)
self.test_run_fields = {
"plan": self.plan.pk,
"build": self.build.pk,
"summary": "TR created",
"manager": UserFactory().pk,
}
def _fixture_setup(self):
super(TestCaseRunCreate, self)._fixture_setup()
self.staff = UserFactory(username='******', email='*****@*****.**')
self.product = ProductFactory(name='Nitrate')
self.version = VersionFactory(value='0.1', product=self.product)
self.build = self.product.build.all()[0]
self.plan = TestPlanFactory(author=self.api_user, owner=self.api_user, product=self.product)
self.test_run = TestRunFactory(product_version=self.version, build=self.build,
default_tester=None, plan=self.plan)
self.case_run_status = TestCaseRunStatus.objects.get(name='IDLE')
self.case = TestCaseFactory(author=self.api_user, default_tester=None, plan=[self.plan])
self.case_run_pks = []
def test_create_with_product_version(self):
version2 = VersionFactory()
test_run_fields = {
'plan': self.plan.pk,
'build': self.build.pk,
'summary': 'TR with product_version',
'manager': self.api_user.pk,
'product_version': version2.pk,
}
result = self.rpc_client.exec.TestRun.create(test_run_fields)
# the result is still using product_version from TR.plan.product_version
# not the one we specified above
self.assertEqual(result['product_version'], self.plan.product_version.value)
def test_with_invalid_version_shows_error(self):
edit_data = self.testplan_edit_data.copy()
# Note: version not assigned to the current Product, that's why
# it is invalid !
version = VersionFactory()
edit_data['product_version'] = version.pk
response = self.client.post(self.testplan_edit_url,
data=edit_data,
follow=True)
self.assertContains(
response,
_('Select a valid choice. That choice is not one of the available choices.'
))
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 _fixture_setup(self):
super(TestFilterCases, self)._fixture_setup()
self.tester = UserFactory(username='******')
self.product = ProductFactory(name='StarCraft')
self.version = VersionFactory(value='0.1', product=self.product)
self.plan = TestPlanFactory(name='Test product.get_cases',
owner=self.tester, author=self.tester,
product=self.product,
product_version=self.version)
self.case_category = CategoryFactory(product=self.product)
self.cases_count = 10
self.cases = [TestCaseFactory(category=self.case_category, author=self.tester,
reviewer=self.tester, default_tester=None,
plan=[self.plan])
for i in range(self.cases_count)]
def test_create_with_product_version(self):
version2 = VersionFactory()
test_run_fields = {
"plan": self.plan.pk,
"build": self.build.pk,
"summary": "TR with product_version",
"manager": self.api_user.pk,
"product_version": version2.pk,
}
result = self.rpc_client.TestRun.create(test_run_fields)
# the result is still using product_version from TR.plan.product_version
# not the one we specified above
self.assertEqual(result["product_version"],
self.plan.product_version.value)
def _fixture_setup(self):
super()._fixture_setup()
self.staff = UserFactory()
self.version = VersionFactory()
self.build = self.version.product.build.first()
self.plan = TestPlanFactory(author=self.api_user,
product=self.version.product)
self.test_run = TestRunFactory(product_version=self.version,
build=self.build,
default_tester=None,
plan=self.plan)
self.status = TestExecutionStatus.objects.filter(weight=0).first()
self.case = TestCaseFactory(author=self.api_user,
default_tester=None,
plan=[self.plan])
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(TestAddTag, self)._fixture_setup()
self.product = ProductFactory()
self.version = VersionFactory()
self.build = self.product.build.first()
self.plan = TestPlanFactory(author=self.api_user, product=self.product)
self.test_runs = [
TestRunFactory(product_version=self.version, build=self.build,
default_tester=None, plan=self.plan),
TestRunFactory(product_version=self.version, build=self.build,
default_tester=None, plan=self.plan),
]
self.tag0 = TagFactory(name='xmlrpc_test_tag_0')
self.tag1 = TagFactory(name='xmlrpc_test_tag_1')
def setUpTestData(cls):
super().setUpTestData()
user_should_have_perm(cls.tester, 'bugs.add_bug')
cls.url = reverse('bugs-new')
cls.summary = 'A shiny new bug!'
cls.product = ProductFactory()
cls.version = VersionFactory(product=cls.product)
cls.build = BuildFactory(product=cls.product)
cls.post_data = {
'summary': cls.summary,
'reporter': cls.tester.pk,
'product': cls.product.pk,
'version': cls.version.pk,
'build': cls.version.pk,
}
