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.test_case = TestCaseFactory()
self.good_component = ComponentFactory(product=self.test_case.category.product)
self.bad_component = ComponentFactory(product=self.test_case.category.product)
self.test_case.add_component(self.good_component)
self.test_case.add_component(self.bad_component)
def setUpTestData(cls):
super(TestOperateComponentView, cls).setUpTestData()
cls.comp_application = ComponentFactory(name='Application',
product=cls.product,
initial_owner=cls.tester,
initial_qa_contact=cls.tester)
cls.comp_database = ComponentFactory(name='Database',
product=cls.product,
initial_owner=cls.tester,
initial_qa_contact=cls.tester)
cls.comp_cli = ComponentFactory(name='CLI',
product=cls.product,
initial_owner=cls.tester,
initial_qa_contact=cls.tester)
cls.comp_api = ComponentFactory(name='API',
product=cls.product,
initial_owner=cls.tester,
initial_qa_contact=cls.tester)
TestCaseComponentFactory(case=cls.case_1, component=cls.comp_cli)
TestCaseComponentFactory(case=cls.case_1, component=cls.comp_api)
user_should_have_perm(cls.tester, 'testcases.add_testcasecomponent')
cls.cases_component_url = reverse('testcases-component')
def setUpTestData(cls):
cls.user = UserFactory()
cls.http_req = make_http_request(
user=cls.user, user_perm='testplans.add_testplancomponent')
cls.product = ProductFactory()
cls.plans = [
TestPlanFactory(author=cls.user,
owner=cls.user,
product=cls.product),
TestPlanFactory(author=cls.user,
owner=cls.user,
product=cls.product),
]
cls.component1 = ComponentFactory(
name='xmlrpc test component 1',
description='xmlrpc test description',
product=cls.product,
initial_owner=None,
initial_qa_contact=None)
cls.component2 = ComponentFactory(
name='xmlrpc test component 2',
description='xmlrpc test description',
product=cls.product,
initial_owner=None,
initial_qa_contact=None)
def setUpTestData(cls):
cls.product_nitrate = ProductFactory(name='nitrate')
cls.product_xmlrpc = ProductFactory(name='xmlrpc')
cls.components = [
ComponentFactory(name='application', product=cls.product_nitrate),
ComponentFactory(name='database', product=cls.product_nitrate),
ComponentFactory(name='documentation', product=cls.product_xmlrpc),
]
def _fixture_setup(self):
super(TestCheckComponent, self)._fixture_setup()
self.product_nitrate = ProductFactory(name='nitrate')
self.product_xmlrpc = ProductFactory(name='xmlrpc')
self.components = [
ComponentFactory(name='application', product=self.product_nitrate),
ComponentFactory(name='database', product=self.product_nitrate),
ComponentFactory(name='documentation',
product=self.product_xmlrpc),
]
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):
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()
def _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.summary = "Tested at " + timezone.now(
).isoformat()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.execution_1.run.summary = (
"Automated TR for BitBucket integration on " +
timezone.now().isoformat())
self.execution_1.run.save()
self.component = ComponentFactory(
name="BitBucket integration",
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name="BitBucket for kiwitcms/test-bitbucket-integration",
tracker_type="tcms.issuetracker.bitbucket.BitBucket",
base_url="https://bitbucket.org/kiwitcms/integration",
api_username=os.getenv("BITBUCKET_INTEGRATION_API_USERNAME"),
api_password=os.getenv("BITBUCKET_INTEGRATION_API_PASSWORD"),
)
self.integration = BitBucket(bug_system, None)
def _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.summary = "Tested at " + timezone.now(
).isoformat()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.execution_1.run.summary = (
"Automated TR for JIRA integration on " +
timezone.now().isoformat())
self.execution_1.run.save()
# this is the name of the JIRA Project
self.execution_1.run.plan.product.name = "Integration with JIRA"
self.execution_1.run.plan.product.save()
self.component = ComponentFactory(
name="JIRA integration", product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name="JIRA at kiwitcms.atlassian.net",
tracker_type="tcms.issuetracker.types.JIRA",
base_url="https://kiwitcms.atlassian.net",
api_username=os.getenv("JIRA_BUGTRACKER_INTEGRATION_API_USERNAME"),
api_password=os.getenv("JIRA_BUGTRACKER_INTEGRATION_API_TOKEN"),
)
self.integration = JIRA(bug_system, None)
def _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.summary = "Tested at " + timezone.now(
).isoformat()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.execution_1.run.summary = (
"Automated TR for Azure integration on " +
timezone.now().isoformat())
self.execution_1.run.save()
self.component = ComponentFactory(
name="AzureBoards integration",
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name="Azure for kiwitcms/test-azure-integration",
tracker_type="tcms.issuetracker.azure_boards.AzureBoards",
base_url="https://dev.azure.com/kiwitcms/boards-integration",
api_password=os.getenv("AZURE_BOARDS_INTEGRATION_API_TOKEN"),
)
self.integration = AzureBoards(bug_system, None)
def test_report_issue_from_test_execution_falls_back_to_query_params(self):
"""
In case 1-click bug-report fails Bugzilla integration will open
a URL with some of the fields pre-defined so the tester will have
an easier time filling in the rest.
"""
# note: automatically creates a version called 'unspecified'
product = ProductFactory(name='Kiwi TCMS')
version, _ = Version.objects.get_or_create(product=product, value='unspecified')
component = ComponentFactory(name='Bugzilla integration', product=product)
test_plan = TestPlanFactory(product=product, product_version=version)
test_case = TestCaseFactory(component=[component], plan=[test_plan])
test_case.save() # will generate history object
test_run = TestRunFactory(plan=test_plan, product_version=version)
execution2 = TestExecutionFactory(run=test_run, case=test_case, build=test_run.build)
# simulate user clicking the 'Report bug' button in TE widget, TR page
result = self.rpc_client.Bug.report(execution2.pk, self.integration.bug_system.pk)
self.assertEqual(result['rc'], 0)
self.assertIn('http://bugtracker.kiwitcms.org/bugzilla/enter_bug.cgi', result['response'])
# assert that the result looks like valid URL parameters
self.assertIn('product=Kiwi+TCMS', result['response'])
self.assertIn('component=Bugzilla+integration', result['response'])
self.assertIn('version=unspecified', result['response'])
expected_description = urlencode({
'short_desc': "Test case failure: %s" % execution2.case.summary,
})
self.assertIn(expected_description, result['response'])
def _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.summary = "Tested at " + timezone.now(
).isoformat()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.execution_1.run.summary = (
"Automated TR for GitHub integration on " +
timezone.now().isoformat())
self.execution_1.run.save()
self.component = ComponentFactory(
name="GitHub integration",
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name="GitHub for kiwitcms/test-github-integration",
tracker_type="tcms.issuetracker.types.GitHub",
base_url="https://github.com/kiwitcms/test-github-integration",
api_password=os.getenv("GH_BUGTRACKER_INTEGRATION_TEST_API_TOKEN"),
)
self.integration = GitHub(bug_system, None)
def setUpTestData(cls):
super(TestCaseRemoveComponent, cls).setUpTestData()
cls.component_1 = ComponentFactory(name='Application',
product=cls.product,
initial_owner=cls.tester,
initial_qa_contact=cls.tester)
cls.component_2 = ComponentFactory(name='Database',
product=cls.product,
initial_owner=cls.tester,
initial_qa_contact=cls.tester)
cls.cc_rel_1 = TestCaseComponentFactory(case=cls.case,
component=cls.component_1)
cls.cc_rel_2 = TestCaseComponentFactory(case=cls.case,
component=cls.component_2)
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(TestUpdateComponent, self)._fixture_setup()
self.product = ProductFactory(name='StarCraft')
self.component = ComponentFactory(name="application",
product=self.product,
initial_owner=None,
initial_qa_contact=None)
def test_new_bug_assignee_inferred_from_components(self):
comp = ComponentFactory(initial_owner=UserFactory(), product=self.product)
self.client.post(self.url, self.post_data, follow=True)
bug_created = Bug.objects.last()
self.assertEqual(bug_created.summary, self.summary)
self.assertEqual(bug_created.assignee, comp.initial_owner)
def setUpTestData(cls):
cls.admin = UserFactory()
cls.staff = UserFactory()
cls.admin_request = make_http_request(user=cls.admin,
user_perm='management.change_component')
cls.staff_request = make_http_request(user=cls.staff)
cls.product = ProductFactory(name='StarCraft')
cls.component = ComponentFactory(name="application", product=cls.product,
initial_owner=None, initial_qa_contact=None)
def test_report_issue_from_test_execution_1click_works(self):
"""
Automatic 1-click bug report to Bugzilla usually works
when Product, Version and Component exist in Bugzilla!
"""
# note: automatically creates a version called 'unspecified'
product = ProductFactory(name="TestProduct")
version, _ = Version.objects.get_or_create(product=product,
value="unspecified")
component = ComponentFactory(name="TestComponent", product=product)
test_plan = TestPlanFactory(product=product, product_version=version)
test_case = TestCaseFactory(component=[component], plan=[test_plan])
test_case.save() # will generate history object
test_run = TestRunFactory(plan=test_plan, product_version=version)
execution2 = TestExecutionFactory(run=test_run,
case=test_case,
build=test_run.build)
# simulate user clicking the 'Report bug' button in TE widget, TR page
result = self.rpc_client.Bug.report(execution2.pk,
self.integration.bug_system.pk)
self.assertEqual(result["rc"], 0)
self.assertIn(
"http://bugtracker.kiwitcms.org/bugzilla/show_bug.cgi?id=",
result["response"],
)
new_bug_id = self.integration.bug_id_from_url(result["response"])
bug = self.integration.rpc.getbug(new_bug_id)
self.assertEqual("TestProduct", bug.product)
self.assertEqual("TestComponent", bug.component)
self.assertEqual("unspecified", bug.version)
self.assertEqual("All", bug.op_sys)
self.assertEqual("All", bug.rep_platform)
last_comment = bug.getcomments()[-1]
for expected_string in [
"Filed from execution %s" % execution2.get_full_url(),
product.name,
component.name,
test_case.text,
]:
self.assertIn(expected_string, last_comment["text"])
# verify that LR has been added to TE
self.assertTrue(
LinkReference.objects.filter(
execution=execution2,
url=result["response"],
is_defect=True,
).exists())
def _fixture_setup(self):
super(TestAddComponent, self)._fixture_setup()
self.product = ProductFactory()
self.plans = [
TestPlanFactory(author=self.api_user,
owner=self.api_user,
product=self.product),
TestPlanFactory(author=self.api_user,
owner=self.api_user,
product=self.product),
]
self.component1 = ComponentFactory(
name='xmlrpc test component 1',
description='xmlrpc test description',
product=self.product,
initial_owner=None,
initial_qa_contact=None)
self.component2 = ComponentFactory(
name='xmlrpc test component 2',
description='xmlrpc test description',
product=self.product,
initial_owner=None,
initial_qa_contact=None)
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 _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.component = ComponentFactory(
name='Gitlab integration',
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name='GitLab-EE for root/kiwitcms',
tracker_type='Gitlab',
base_url='http://bugtracker.kiwitcms.org/root/kiwitcms/',
api_url='http://bugtracker.kiwitcms.org',
api_password='******',
)
self.integration = Gitlab(bug_system)
def _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.component = ComponentFactory(
name="Gitlab integration",
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name="GitLab-EE for root/kiwitcms",
tracker_type="tcms.issuetracker.types.Gitlab",
base_url="https://gitlab.com/kiwitcms/integration-testing/",
api_url="https://gitlab.com",
api_password=os.getenv("GITLAB_INTEGRATION_API_TOKEN"),
)
self.integration = Gitlab(bug_system, None)
def _fixture_setup(self):
super()._fixture_setup()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.save() # will generate history object
# this is the name of the Redmine Project
self.execution_1.run.plan.product.name = 'Integration with Kiwi TCMS'
self.execution_1.run.plan.product.save()
self.component = ComponentFactory(name='Redmine integration',
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name='Redmine at kiwitcms.atlassian.net',
tracker_type='Redmine',
base_url='http://bugtracker.kiwitcms.org:3000',
api_username='******',
api_password='******',
)
self.integration = Redmine(bug_system)
def _fixture_setup(self):
super()._fixture_setup()
self.existing_bug = BugFactory()
self.execution_1 = TestExecutionFactory()
self.execution_1.case.text = "Given-When-Then"
self.execution_1.case.save() # will generate history object
self.component = ComponentFactory(
name='KiwiTCMS integration',
product=self.execution_1.run.plan.product)
self.execution_1.case.add_component(self.component)
bug_system = BugSystem.objects.create( # nosec:B106:hardcoded_password_funcarg
name='KiwiTCMS internal bug tracker',
tracker_type='tcms.issuetracker.types.KiwiTCMS',
base_url="https://%s" %
Site.objects.get(id=settings.SITE_ID).domain,
# note: ^^^ this is https just because .get_full_url() default to that !
)
self.integration = KiwiTCMS(bug_system, None)
def setUpTestData(cls):
super(TestAddComponent, cls).setUpTestData()
cls.component_db = ComponentFactory(name='db', product=cls.product)
cls.component_doc = ComponentFactory(name='doc', product=cls.product)
cls.component_cli = ComponentFactory(name='cli', product=cls.product)
def _fixture_setup(self):
super(TestGetComponent, self)._fixture_setup()
self.product = ProductFactory(name='StarCraft')
self.component = ComponentFactory(name='application',
product=self.product)
def setUpTestData(cls):
cls.product = ProductFactory(name='StarCraft')
cls.component = ComponentFactory(name='application',
product=cls.product)
def setUpTestData(cls):
cls.product = ProductFactory(name='StarCraft')
cls.component = ComponentFactory(name='application',
product=cls.product,
initial_owner=None,
initial_qa_contact=None)
def setUpTestData(cls):
cls.testcase = TestCaseFactory(component=[
ComponentFactory(),
ComponentFactory(),
ComponentFactory()
])
