def setUpTestData(cls):
cls.status_idle = TestCaseRunStatus.objects.get(name='IDLE')
cls.tester = UserFactory()
cls.case_run = TestCaseRunFactory(assignee=cls.tester,
tested_by=None,
notes='testing ...',
case_run_status=cls.status_idle)
def setUpTestData(cls):
super(TestSortCases, cls).setUpTestData()
cls.plan_tester = UserFactory(username='******')
cls.plan_tester.set_password('password')
cls.plan_tester.save()
cls.cases_url = reverse('plan-reorder-cases', args=[cls.plan.pk])
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 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(TestDeleteCasesFromPlan, cls).setUpTestData()
cls.plan_tester = UserFactory(username='******')
cls.plan_tester.set_password('password')
cls.plan_tester.save()
cls.cases_url = reverse('plan-delete-cases', args=[cls.plan.pk])
def setUpTestData(cls):
super(TestLogout, cls).setUpTestData()
cls.tester = UserFactory()
cls.tester.set_password('password')
cls.tester.save()
cls.logout_url = reverse('tcms-logout')
def setUpTestData(cls):
cls.product = ProductFactory()
cls.version = VersionFactory(value='0.1', product=cls.product)
cls.build = TestBuildFactory(product=cls.product)
cls.user = UserFactory()
cls.test_run = TestRunFactory(manager=cls.user, default_tester=None,
build=cls.build)
def _fixture_setup(self):
super()._fixture_setup()
self.testcase = TestCaseFactory(
summary="Sanity test case", text="Given-When-Then", default_tester=None
)
self.new_author = UserFactory()
def setUpTestData(cls):
cls.case_author = UserFactory()
cls.plans = [
TestPlanFactory(),
TestPlanFactory(),
TestPlanFactory(),
]
TestCaseFactory(author=cls.case_author,
default_tester=None,
plan=[cls.plans[0]])
TestCaseFactory(author=cls.case_author,
default_tester=None,
plan=[cls.plans[0]])
TestCaseFactory(author=cls.case_author,
default_tester=None,
plan=[cls.plans[1]])
TestCaseFactory(author=cls.case_author,
default_tester=None,
plan=[cls.plans[2]])
TestCaseFactory(author=cls.case_author,
default_tester=None,
plan=[cls.plans[2]])
TestCaseFactory(author=cls.case_author,
default_tester=None,
plan=[cls.plans[2]])
plan_keys = []
for plan in cls.plans:
plan_keys.append(plan.pk)
cls.plans = TestPlan.objects.filter(pk__in=plan_keys)
cls.plan_serializer = MockTestPlanSerializer(TestPlan, cls.plans)
cls.cases = [
TestCaseFactory(author=cls.case_author, default_tester=None),
TestCaseFactory(author=cls.case_author, default_tester=None),
TestCaseFactory(author=cls.case_author, default_tester=None),
]
case_keys = []
for case in cls.cases:
case_keys.append(case.pk)
cls.cases = TestCase.objects.filter(pk__in=case_keys)
cls.case_serializer = MockTestCaseSerializer(TestCase, cls.cases)
cls.products = [ProductFactory(), ProductFactory(), ProductFactory()]
product_keys = []
for product in cls.products:
product_keys.append(product.pk)
cls.products = Product.objects.filter(pk__in=product_keys)
cls.product_serializer = QuerySetBasedRPCSerializer(
Product, cls.products)
def setUpTestData(cls):
cls.user = UserFactory()
cls.http_req = make_http_request(user=cls.user,
user_perm='testcases.change_testcase')
cls.default_cc = '*****@*****.**'
cls.testcase = TestCaseFactory()
cls.testcase.emailing.add_cc(cls.default_cc)
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(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.status_idle = TestExecutionStatus.objects.filter(weight=0).first()
self.tester = UserFactory()
self.execution = TestExecutionFactory(
assignee=self.tester, tested_by=None, sortkey=10, status=self.status_idle
)
def _fixture_setup(self):
# restore the serialized data from initial migrations
# this includes default groups and permissions
super()._fixture_setup()
self.check_mandatory_attributes()
self.tester = UserFactory()
self.tester.set_password('password')
self.tester.save()
# this is the XML-RPC ServerProxy with cookies support
self.rpc_client = tcms_api.xmlrpc.TCMSXmlrpc(
self.tester.username,
'password',
'%s/xml-rpc/' % self.live_server_url,
).server
def _fixture_setup(self):
super(TestBuildGetCaseRuns, self)._fixture_setup()
self.product = ProductFactory()
self.build = TestBuildFactory(product=self.product)
self.user = UserFactory()
self.case_run_1 = TestCaseRunFactory(assignee=self.user, build=self.build)
self.case_run_2 = TestCaseRunFactory(assignee=self.user, build=self.build)
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 _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):
cls.admin = UserFactory(username='******',
email='*****@*****.**')
cls.admin_request = make_http_request(
user=cls.admin, user_perm='testruns.change_testcaserun')
cls.case_run_1 = TestCaseRunFactory()
cls.case_run_2 = TestCaseRunFactory()
def _fixture_setup(self):
super()._fixture_setup()
self.status_idle = TestExecutionStatus.objects.get(name='IDLE')
self.tester = UserFactory()
self.case_run = TestExecutionFactory(assignee=self.tester, tested_by=None,
sortkey=10,
status=self.status_idle)
def _fixture_setup(self):
super()._fixture_setup()
self.user = UserFactory()
self.execution_1 = TestExecutionFactory()
self.status_positive = TestExecutionStatus.objects.filter(weight__gt=0).last()
self.status_negative = TestExecutionStatus.objects.filter(weight__lt=0).last()
self.status_in_progress = TestExecutionStatus.objects.filter(weight=0).last()
def setUpTestData(cls):
super().setUpTestData()
initiate_user_with_default_setups(cls.tester)
cls.comment_bug_url = reverse("bugs-comment")
user_should_have_perm(cls.tester, "bugs.change_bug")
cls.assignee = UserFactory()
cls.url = reverse("bugs-comment")
def _fixture_setup(self):
super(TestCaseRunFilter, self)._fixture_setup()
self.status_idle = TestCaseRunStatus.objects.get(name='IDLE')
self.tester = UserFactory()
self.case_run = TestCaseRunFactory(assignee=self.tester, tested_by=None,
notes='testing ...',
sortkey=10,
case_run_status=self.status_idle)
def setUpTestData(cls):
cls.user = UserFactory(username='******', email='*****@*****.**')
cls.priority = Priority.objects.get(value='P1')
cls.status_confirmed = TestCaseStatus.objects.get(name='CONFIRMED')
cls.original_xml_version = None
if hasattr(settings, 'TESTOPIA_XML_VERSION'):
cls.original_xml_version = settings.TESTOPIA_XML_VERSION
settings.TESTOPIA_XML_VERSION = 1.1
def _fixture_setup(self):
super(TestUserFilter, self)._fixture_setup()
self.group_tester = GroupFactory()
self.group_reviewer = GroupFactory()
self.user1 = UserFactory(username='******',
email='*****@*****.**',
is_active=True,
groups=[self.group_tester])
self.user2 = UserFactory(username='******',
email='*****@*****.**',
is_active=False,
groups=[self.group_reviewer])
self.user3 = UserFactory(username='******',
email='*****@*****.**',
is_active=True,
groups=[self.group_reviewer])
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 setUpTestData(cls):
cls.user = UserFactory(username='******', email='*****@*****.**')
cls.user.set_password('admin')
cls.user.is_superuser = True
cls.user.is_staff = True # enables access to admin panel
cls.user.save()
cls.c = Client()
cls.c.login(username='******', password='******')
def _fixture_setup(self):
super()._fixture_setup()
self.staff = UserFactory()
self.user = 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):
# Note: by default the logged-in user is self.tester
super().setUpTestData()
cls.admin = UserFactory()
cls.admin.is_superuser = True
cls.admin.set_password('admin-password')
cls.admin.save()
def setUpTestData(cls):
super().setUpTestData()
initiate_user_with_default_setups(cls.tester)
cls.test_run = TestRunFactory()
cls.superuser = UserFactory()
cls.superuser.is_superuser = True
cls.superuser.set_password("password")
cls.superuser.save()
def setUpTestData(cls):
cls.group_tester = GroupFactory()
cls.group_reviewer = GroupFactory()
cls.user1 = UserFactory(username='******',
email='*****@*****.**',
is_active=True,
groups=[cls.group_tester])
cls.user2 = UserFactory(username='******',
email='*****@*****.**',
is_active=False,
groups=[cls.group_reviewer])
cls.user3 = UserFactory(username='******',
email='*****@*****.**',
is_active=True,
groups=[cls.group_reviewer])
cls.http_req = make_http_request()
def create_request_user(username=None, password=None):
if username:
user = UserFactory(username=username)
else:
user = UserFactory()
if password:
user.set_password(password)
else:
user.set_password('password')
user.save()
return user
