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, }