def setUpTestData(cls):
cls.product = ProductFactory()
cls.request = HttpRequest()
cls.info_objects = _InfoObjects(cls.request, cls.product.pk)
cls.build_one = BuildFactory(product=cls.product)
cls.build_two = BuildFactory(product=cls.product)
cls.build_two.is_active = False
cls.build_two.save()
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.env_group_one = EnvGroupFactory()
cls.env_group_two = EnvGroupFactory()
cls.env_property_one = EnvPropertyFactory()
cls.env_property_two = EnvPropertyFactory()
EnvGroupPropertyMapFactory(group=cls.env_group_one, property=cls.env_property_one)
cls.env_value_one = EnvValueFactory(property=cls.env_property_one)
cls.env_value_two = EnvValueFactory()
cls.user_one = UserFactory()
cls.user_two = UserFactory()
cls.version_one = VersionFactory(product=cls.product)
cls.version_two = VersionFactory()
def _fixture_setup(self):
super()._fixture_setup()
self.version = VersionFactory()
self.another_version = VersionFactory()
self.build_1 = BuildFactory(version=self.version)
self.build_2 = BuildFactory(version=self.version)
self.build_3 = BuildFactory(version=self.version)
def _fixture_setup(self):
super()._fixture_setup()
self.product = ProductFactory()
self.another_product = ProductFactory()
self.build_1 = BuildFactory(product=self.product)
self.build_2 = BuildFactory(product=self.product)
self.build_3 = BuildFactory(product=self.product)
def test_generate_testing_report(self):
# test for https://github.com/kiwitcms/Kiwi/issues/88
#
run = TestRunFactory()
product_build = BuildFactory(product=run.plan.product)
for status in TestCaseRunStatus.objects.all():
TestCaseRunFactory(case_run_status=status,
run=run,
build=product_build)
# Create an untested testcase run to assert that issue #88 does not arise.
TestCaseRunFactory(
tested_by=None,
case_run_status=TestCaseRunStatus.objects.get(name='IDLE'),
run=run,
build=product_build,
)
url = reverse('testing-report')
response = self.client.get(url, {
'r_product': run.plan.product.pk,
'report_type': 'per_build_report'
})
self.assertEqual(HTTPStatus.OK, response.status_code)
def test_edit_bug(self):
summary_edit = 'An edited summary'
version_edit = VersionFactory()
build_edit = BuildFactory()
edit_data = {
'summary': summary_edit,
'version': version_edit.pk,
'build': build_edit.pk,
'reporter': self.bug.reporter.pk,
'assignee': self.bug.assignee.pk,
'product': self.bug.product.pk
}
response = self.client.post(self.url, edit_data, follow=True)
self.assertRedirects(
response,
reverse('bugs-get', args=(self.bug.pk,)),
status_code=302,
target_status_code=200
)
self.bug.refresh_from_db()
self.assertEqual(self.bug.summary, summary_edit)
self.assertEqual(self.bug.version, version_edit)
self.assertEqual(self.bug.build, build_edit)
self.assertEqual(self.bug.created_at, self.created_at)
def test_edit_bug(self):
summary_edit = "An edited summary"
version_edit = VersionFactory()
build_edit = BuildFactory()
edit_data = {
"summary": summary_edit,
"version": version_edit.pk,
"build": build_edit.pk,
"reporter": self.bug.reporter.pk,
"assignee": self.bug.assignee.pk,
"product": self.bug.product.pk,
}
response = self.client.post(self.url, edit_data, follow=True)
self.assertRedirects(
response,
reverse("bugs-get", args=(self.bug.pk, )),
status_code=302,
target_status_code=200,
)
self.bug.refresh_from_db()
self.assertEqual(self.bug.summary, summary_edit)
self.assertEqual(self.bug.version, version_edit)
self.assertEqual(self.bug.build, build_edit)
self.assertEqual(self.bug.created_at, self.created_at)
def test_report_by_caserun_tester_loads(self):
# test for https://github.com/kiwitcms/Kiwi/issues/88
#
run = TestRunFactory()
product_build = BuildFactory(product=run.plan.product)
for status in TestCaseRunStatus.objects.all():
TestCaseRunFactory(case_run_status=status,
run=run,
build=product_build)
self.untested_tcr = TestCaseRunFactory(
tested_by=None,
case_run_status=TestCaseRunStatus.objects.get(name='IDLE'),
run=run,
build=product_build,
)
url = reverse('testing-report')
response = self.client.get(url, {
'r_product': run.plan.product.pk,
'report_type': 'per_build_report'
})
self.assertEqual(http.client.OK, response.status_code)
def setUpTestData(cls):
super().setUpTestData()
user_should_have_perm(cls.tester, "bugs.view_bug")
ProductFactory()
VersionFactory()
BuildFactory()
def setUpTestData(cls):
super(TestCreateNewRun, cls).setUpTestData()
cls.permission = 'testruns.add_testrun'
user_should_have_perm(cls.tester, cls.permission)
cls.url = reverse('testruns-new')
cls.build_fast = BuildFactory(name='fast', product=cls.product)
def test_history(self):
"""
Test that for an execution that has been updated 3 times,
there are 4 history entries (first one is the creation of the object).
Note: the `time.sleep` call after every update is necessary,
because otherwise the changes happen too fast,
and the XML-RPC protocol follows ISO 8601 which doesn't have sub-seconds precision.
Hence the measurable delta is 1 second.
"""
time.sleep(1)
self.execution.build = BuildFactory()
self.execution.save()
time.sleep(1)
user = UserFactory()
self.execution.assignee = user
self.execution.save()
time.sleep(1)
self.execution.tested_by = user
self.execution.save()
time.sleep(1)
history = self.rpc_client.TestExecution.history(self.execution.pk)
self.assertEqual(4, len(history))
# assert entries are in the right order
previous = timezone.now()
for history_entry in history:
self.assertTrue(history_entry["history_date"] < previous)
previous = history_entry["history_date"]
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(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")
for tag in [self.tag0, self.tag1]:
self.test_runs[0].add_tag(tag)
self.test_runs[1].add_tag(tag)
def test_update_with_product(self):
test_run = TestRunFactory()
product = ProductFactory()
updated_test_plan = TestPlanFactory(product=product)
updated_build = BuildFactory(version=product.version.first())
updated_summary = "Updated summary."
updated_stop_date = "2020-05-05 00:00:00"
updated_test_run = self.rpc_client.TestRun.update(
test_run.pk,
{
"plan": updated_test_plan.pk,
"product": product.id,
"build": updated_build.pk,
"summary": updated_summary,
"stop_date": updated_stop_date,
},
)
test_run.refresh_from_db()
self.assertEqual(updated_test_run["plan"], updated_test_plan.pk)
self.assertEqual(updated_test_run["build"], updated_build.pk)
self.assertEqual(updated_test_run["summary"], updated_summary)
self.assertEqual(updated_test_run["stop_date"], test_run.stop_date)
def _fixture_setup(self):
super(TestCaseRunUpdate, self)._fixture_setup()
self.user = UserFactory()
self.build = BuildFactory()
self.case_run_1 = TestCaseRunFactory()
self.case_run_2 = TestCaseRunFactory()
self.status_running = TestCaseRunStatus.objects.get(name='RUNNING')
def _fixture_setup(self):
super()._fixture_setup()
self.user = UserFactory()
self.build = BuildFactory()
self.case_run_1 = TestExecutionFactory()
self.case_run_2 = TestExecutionFactory()
self.status_running = TestExecutionStatus.objects.get(name='RUNNING')
def setUpTestData(cls):
super(TestCaseRemoveBug, cls).setUpTestData()
cls.build = BuildFactory(product=cls.product)
cls.test_run = TestRunFactory(product_version=cls.version, plan=cls.plan,
manager=cls.tester, default_tester=cls.tester)
cls.case_run = TestCaseRunFactory(assignee=cls.tester, tested_by=cls.tester,
case=cls.case, run=cls.test_run, build=cls.build)
cls.bug_system = BugSystem.objects.get(name='Bugzilla')
def setUpTestData(cls):
super().setUpTestData()
cls.build = BuildFactory(version=cls.plan.product_version)
user_should_have_perm(cls.tester, "testruns.add_testrun")
user_should_have_perm(cls.tester, "testruns.view_testrun")
cls.url = reverse("testruns-new")
def setUpTestData(cls):
super().setUpTestData()
cls.build = BuildFactory(product=cls.product)
user_should_have_perm(cls.tester, 'testruns.add_testrun')
user_should_have_perm(cls.tester, 'testruns.view_testrun')
cls.url = reverse('testruns-new')
def _fixture_setup(self):
super()._fixture_setup()
self.user = UserFactory()
self.build = BuildFactory()
self.execution_1 = TestExecutionFactory()
self.execution_2 = TestExecutionFactory()
self.status_positive = TestExecutionStatus.objects.filter(weight__gt=0).last()
def _fixture_setup(self):
super()._fixture_setup()
self.test_run = TestRunFactory()
self.updated_test_plan = TestPlanFactory()
self.updated_build = BuildFactory()
self.updated_summary = "Updated summary."
self.updated_stop_date = datetime.strptime("2020-05-05", "%Y-%m-%d")
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_build = BuildFactory(name='FastTest',
product=cls.test_run.plan.product)
cls.intern = UserFactory(username='******', email='*****@*****.**')
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(author=self.api_user,
product=self.product,
product_version=self.version)
def setUpTestData(cls):
super().setUpTestData()
cls.status_idle = TestExecutionStatus.objects.filter(weight=0).first()
cls.build = BuildFactory(version=cls.version)
cls.test_run = TestRunFactory(
product_version=cls.version,
plan=cls.plan,
build=cls.build,
manager=cls.tester,
default_tester=cls.tester,
)
executions = []
for i, case in enumerate((cls.case_1, cls.case_2, cls.case_3), 1):
executions.append(
TestExecutionFactory(
assignee=cls.tester,
run=cls.test_run,
build=cls.build,
status=cls.status_idle,
case=case,
sortkey=i * 10,
))
# used in other tests as well
cls.execution_1 = executions[0]
cls.execution_2 = executions[1]
cls.execution_3 = executions[2]
cls.test_run_1 = TestRunFactory(
product_version=cls.version,
plan=cls.plan,
build=cls.build,
manager=cls.tester,
default_tester=cls.tester,
)
# create a few more TestExecution objects
for i, case in enumerate((cls.case_4, cls.case_5, cls.case_6), 1):
executions.append(
TestExecutionFactory(
assignee=cls.tester,
tested_by=cls.tester,
run=cls.test_run_1,
build=cls.build,
status=cls.status_idle,
case=case,
sortkey=i * 10,
))
# used in other tests as well
cls.execution_4 = executions[3]
cls.execution_5 = executions[4]
cls.execution_6 = executions[5]
def _fixture_setup(self):
super()._fixture_setup()
self.test_run = TestRunFactory()
self.update_fields = {
'plan': TestPlanFactory().pk,
'build': BuildFactory().pk,
'summary': 'Updated summary.',
'stop_date': '2020-05-05 00:00:00'
}
def _fixture_setup(self):
super()._fixture_setup()
self.test_run = TestRunFactory()
self.update_fields = {
"plan": TestPlanFactory().pk,
"build": BuildFactory().pk,
"summary": "Updated summary.",
"stop_date": "2020-05-05 00:00:00",
}
def setUpTestData(cls):
super(BaseCaseRun, cls).setUpTestData()
# todo: we need a linter to find all places where we get statuses
# by hard-coded names instead of class based attribute constants!
cls.case_run_status_idle = TestCaseRunStatus.objects.get(name='IDLE')
cls.build = BuildFactory(product=cls.product)
cls.test_run = TestRunFactory(product_version=cls.version,
plan=cls.plan,
build=cls.build,
manager=cls.tester,
default_tester=cls.tester)
case_runs = []
for i, case in enumerate((cls.case_1, cls.case_2, cls.case_3), 1):
case_runs.append(
TestCaseRunFactory(assignee=cls.tester,
run=cls.test_run,
build=cls.build,
case_run_status=cls.case_run_status_idle,
case=case,
sortkey=i * 10))
# used in other tests as well
cls.case_run_1 = case_runs[0]
cls.case_run_2 = case_runs[1]
cls.case_run_3 = case_runs[2]
cls.test_run_1 = TestRunFactory(product_version=cls.version,
plan=cls.plan,
build=cls.build,
manager=cls.tester,
default_tester=cls.tester)
# create a few more TestCaseRun objects
for i, case in enumerate((cls.case_4, cls.case_5, cls.case_6), 1):
case_runs.append(
TestCaseRunFactory(assignee=cls.tester,
tested_by=cls.tester,
run=cls.test_run_1,
build=cls.build,
case_run_status=cls.case_run_status_idle,
case=case,
sortkey=i * 10))
# used in other tests as well
cls.case_run_4 = case_runs[3]
cls.case_run_5 = case_runs[4]
cls.case_run_6 = case_runs[5]
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 setUpTestData(cls):
cls.product = ProductFactory()
cls.request = HttpRequest()
cls.info_objects = _InfoObjects(cls.request, cls.product.pk)
cls.build_one = BuildFactory(product=cls.product)
cls.build_two = BuildFactory(product=cls.product)
cls.build_two.is_active = False
cls.build_two.save()
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 test_changes_build(self):
# simulate what happens in reality where TestExeuctions are created
# taking their initial .build values from the parent TestRun
self.execution_1.build = self.execution_1.run.build
self.execution_1.save()
# now simulate a re-test scenario where TR.build has already changed
# e.g. longer test cycle covering multiple builds
self.execution_1.run.build = BuildFactory(name="b02")
self.execution_1.run.save()
self.rpc_client.TestExecution.update(
self.execution_1.pk, {"status": self.status_positive.pk})
self.execution_1.refresh_from_db()
self.assertEqual(self.execution_1.status, self.status_positive)
self.assertEqual(self.execution_1.build.name, "b02")
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,
}
def setUpTestData(cls):
super().setUpTestData()
user_should_have_perm(cls.tester, "bugs.add_bug")
user_should_have_perm(cls.tester, "bugs.view_bug")
cls.url = reverse("bugs-new")
cls.summary = "A shiny new bug!"
cls.product = ProductFactory()
cls.version = VersionFactory(product=cls.product)
cls.build = BuildFactory(version=cls.version)
cls.post_data = {
"summary": cls.summary,
"reporter": cls.tester.pk,
"product": cls.product.pk,
"version": cls.version.pk,
"build": cls.build.pk,
}
