def revert_svn():
proj = Project(Project.default_project)
proj_grp = proj.project_group.name
svn_url = "%s/%s/%s" % (proj.repo, proj_grp, proj.project_id)
LOCAL_DIR = "/tmp/%s" % proj.project_id
USER = proj.logged_in_user_id
PASS = proj.session.password
svn = pysvn.Client()
svn.set_default_username(USER)
svn.set_default_password(PASS)
svn.set_store_passwords(False)
svn.checkout(svn_url, LOCAL_DIR)
svn_log = svn.log(LOCAL_DIR)
# first_revision = svn_log[-1].revision
for log in svn_log:
if log.revision.number == REVERT_TO:
break
first_revision = log.revision
last_revision = svn_log[0].revision
svn.merge(LOCAL_DIR, last_revision, LOCAL_DIR, first_revision, LOCAL_DIR)
svn.checkin(LOCAL_DIR, "revert to original version")
# The original Example template query has an extra colon.
# After revert, must fix that.
tmpl = TestRun(project_id=proj.project_id, test_run_id="Example")
tmpl.query = tmpl.query.replace("::", ":")
tmpl.update()
def update_all_case_results_for_run(self, run, result, user, comment):
run = run.strip()
tr = TestRun(run, None, TestRun.default_project)
print('\nUpdate %s:' % run)
if not comment:
comment = ''
print('Total records: %d' % len(tr.records))
print('Updated Date Time Result CaseID')
print('------------------- ------ -----------')
if user == 'None':
user = TestRun.logged_in_user_id
for rec in tr.records:
rec.executed = datetime.datetime.now()
rec.executed_by = user
executed_str = str(rec.executed).split('.')[0]
rec.result = result
rec.comment = comment
print('%-20s %-7s %s' % (executed_str, result, rec.test_case_id))
tr.update_test_record_by_object(rec.test_case_id, rec)
print('Done!')
def update_all_results_for_run(self, run, result, user, comment):
tr = TestRun(run.strip(), None, TestRun.default_project)
print 'Update %s:' % run.strip()
if not comment:
comment = ''
print 'Total records: %d' % len(tr.records)
print 'Updated Date Time Result CaseID'
print '------------------- ------ -----------'
if user == 'None':
user = TestRun.logged_in_user_id
for rec in tr.records:
rec.executed = datetime.datetime.now()
rec.executed_by = user
executed_str = str(rec.executed).split('.')[0]
rec.result = result
rec.comment = comment
print '%-20s %-7s %s' % (executed_str,
result,
rec.test_case_id)
tr.update_test_record_by_object(rec.test_case_id,
rec)
print 'Done!'
def update_1_result_for_run(self,
run,
testcase,
result,
user,
comment):
if not comment:
comment = ''
tr = TestRun(run.strip(), None, TestRun.default_project)
print 'Update %s:' % run
if user == 'None':
user = TestRun.logged_in_user_id
for rec in tr.records:
rec.executed = datetime.datetime.now()
rec.executed_by = user
rec.result = result
rec.comment = comment
if rec.test_case_id == testcase:
tr.update_test_record_by_object(testcase, rec)
print '%4sSet %s to %s (verdict %s)' % ('',
testcase,
result,
comment)
print 'Done!'
def test_001_create_template(self):
"""This test does the following:
* Creates a TestRun template based on the "Empty" template
* Verifies that the returned object exists and is a template
* Adds a custom field as a kwarg
* Tries to create another template with an invalid enum value in kwarg
* Tries to create another template with an invalid kwarg
"""
global TEMPLATE_ID
template = TestRun.create_template(DEFAULT_PROJ,
TEMPLATE_ID,
"Empty",
title=TEMPLATE_TITLE,
arch="i386")
TEMPLATE_ID = template.test_run_id
self.assertIsNotNone(template.test_run_id)
self.assertTrue(template.is_template)
self.assertEqual(template.arch, "i386")
with self.assertRaises(PylarionLibException):
template = TestRun.create_template(DEFAULT_PROJ,
TEMPLATE_ID + "1",
"Empty",
TEMPLATE_TITLE + "1",
arch="BAD")
with self.assertRaises(PylarionLibException):
template = TestRun.create_template(DEFAULT_PROJ,
TEMPLATE_ID + "2",
"Empty",
TEMPLATE_TITLE + "2",
notaparm="BAD")
def update_1_case_result_for_run(self, run, testcase, result, user,
comment):
if not comment:
comment = ''
tr = TestRun(run.strip(), None, TestRun.default_project)
print('Update %s:' % run)
if user == 'None':
user = TestRun.logged_in_user_id
is_found = False
for rec in tr.records:
if rec.test_case_id == testcase:
is_found = True
rec.executed = datetime.datetime.now()
rec.executed_by = user
rec.result = result
rec.comment = comment
tr.update_test_record_by_object(testcase, rec)
print("%4sSet %s to %s (verdict comment: '%s')" %
('', testcase, result, comment))
return 0
if not is_found:
print('Test case %s is not found in run.' % testcase)
def test_run(path, test_run_id, test_template_id, user, project):
"""Execute a test run based on jUnit XML file."""
results = parse_junit(path)
try:
test_run = TestRun(test_run_id, project_id=project)
click.echo('Test run {0} found.'.format(test_run_id))
except PylarionLibException as err:
click.echo(err, err=True)
click.echo('Creating test run {0}.'.format(test_run_id))
test_run = TestRun.create(project, test_run_id, test_template_id)
for result in results:
test_case_id = '{0}.{1}'.format(result['classname'], result['name'])
test_case = TestCase.query(test_case_id)
if len(test_case) == 0:
click.echo(
'Was not able to find test case with id {0}, skipping...'.
format(test_case_id))
continue
status = POLARION_STATUS[result['status']]
work_item_id = test_case[0].work_item_id
click.echo(
'Adding test record for test case {0} with status {1}.'.format(
work_item_id, status))
try:
test_run.add_test_record_by_fields(
test_case_id=work_item_id,
test_result=status,
test_comment=result.get('message'),
executed_by=user,
executed=datetime.datetime.now(),
duration=float(result.get('time', '0')))
except PylarionLibException as err:
click.echo('Skipping test case {0}.'.format(work_item_id))
click.echo(err, err=True)
def update_status_for_run(self,
run,
status):
tr = TestRun(run.strip(), None, TestRun.default_project)
tr.status = status
tr.update()
print 'Updated %s status -> %s' % (run, status)
def test_custom_testrun(self):
testrun = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
self.assertIsNotNone(testrun.arch)
with self.assertRaises(PylarionLibException):
testrun.arch = "bad"
valid_values = testrun.get_valid_field_values("arch")
testrun.arch = valid_values[0]
self.assertEqual(valid_values[0], testrun.arch)
def update_run(self,
run,
template=None,
plannedin=None,
assignee=None,
status=None,
description=None,
is_template=False):
run = run.strip()
query_ful = 'project.id:%s AND id:%s' % (TestRun.default_project, run)
fields = [
'query', 'created', 'test_run_id', 'select_test_cases_by',
'status', 'plannedin', 'assignee', 'author'
]
st = TestRun.search(query_ful, fields, 'created', -1, is_template)
# Update run if exists, otherwise create it.
if st:
print('Update the existing run: %s' % run)
tr = TestRun(run, None, TestRun.default_project)
# set fields
if assignee != 'None':
tr.assignee = assignee
print('%4sSet Assignee to %s' % ('', assignee))
if plannedin is not None:
tr.plannedin = plannedin
print('%4sSet Plannedin to %s' % ('', plannedin))
if status is not None:
tr.status = status
print('%4sSet Status to %s' % ('', status))
if description is not None:
tr.description = description
print('%4sSet Description to %s' % ('', description))
tr.update()
else:
tr = TestRun.create(TestRun.default_project,
run,
template,
assignee=assignee,
plannedin=plannedin,
status=status,
description=description)
# display fields
if assignee != 'None':
print('%4sSet Assignee to %s' % ('', assignee))
if plannedin is not None:
print('%4sSet Plannedin to %s' % ('', plannedin))
if status is not None:
print('%4sSet Status to %s' % ('', status))
if description is not None:
print('%4sSet Description to %s' % ('', description))
print('Created %s:' % run)
def test_uri_obj(self):
testrun2 = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
self.assertEqual(testrun2.template, "example")
new_template = TestRun.create_template(DEFAULT_PROJ,
TEMPLATE_ID,
"example",
title=TEMPLATE_TITLE)
testrun2.template = new_template
self.assertEqual(testrun2.template, new_template.test_run_id)
self.assertNotEqual(testrun2.template, "example")
def test_003_get(self):
"""This test does the following:
* Verifies error with invalid test_run_id
* Gets a valid TestRun
* verifies that the TestRun retrieves has the expected test_run_id
"""
with self.assertRaises(PylarionLibException):
TestRun(project_id=DEFAULT_PROJ, test_run_id="InValid")
tr = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
self.assertEqual(tr.test_run_id, TEST_RUN_ID)
def test_custom_testrun2(self):
"""this test does the following:
* Instantiate an empty test run.
* verify that the custom field exists and is None
* test an invalid value
* test a valid value
* verify that it saves it in the attribute
"""
testrun = TestRun()
self.assertIsNone(testrun.arch)
with self.assertRaises(PylarionLibException):
testrun.arch = "bad"
valid_values = testrun.get_valid_field_values("arch")
testrun.arch = valid_values[0]
self.assertEqual(valid_values[0], testrun.arch)
def test_002_5_create_run_with_title(self):
"""This test does the following:
* creates a test run based on the template created in previous test
* with both a title and an id
* with just a title.
* Verifies that the returned object exists and is not a template
"""
tr1 = TestRun.create(DEFAULT_PROJ, TEST_RUN_ID2, TEMPLATE_ID, TITLE1)
self.assertIsNotNone(tr1.test_run_id)
self.assertEqual(tr1.title, TITLE1)
self.assertFalse(tr1.is_template)
tr2 = TestRun.create(DEFAULT_PROJ, None, TEMPLATE_ID, TITLE2)
self.assertIsNotNone(tr2.test_run_id)
self.assertEqual(tr2.title, TITLE2)
self.assertFalse(tr2.is_template)
def test_009_dynamic_records(self):
"""This test does the following:
* creates a TestCase
* creates a TestRun based on the Example template (Dynamic query)
* verifies that it is a dynamic query
* updates an test record.
* reloads
* verifies that the record has been added
"""
TestCase.create(DEFAULT_PROJ,
TIME_STAMP,
"regression",
caseimportance="high",
caselevel="component",
caseautomation="notautomated",
caseposneg="positive",
testtype="functional",
subtype1="-")
tr = TestRun.create("proj1",
"querytest-%s" % TIME_STAMP,
"Example",
"querytest-%s" % TIME_STAMP,
query=TIME_STAMP)
self.assertEquals(tr.select_test_cases_by, "dynamicQueryResult")
num_recs = len(tr.records)
test_case_id = tr.records[0].test_case_id
tr.update_test_record_by_fields(test_case_id, "blocked", "comment",
tr.logged_in_user_id,
datetime.datetime.now(), 0)
tr.reload()
self.assertEquals(num_recs, len(tr.records))
self.assertEquals(test_case_id, tr.records[0].test_case_id)
self.assertEquals(tr.records[0].result, "blocked")
def get_template(self, temp_id):
"""
Gets a TestRun template
:param temp_id:
:return:
"""
from pylarion.test_run import TestRun
for x in ["-", "."]:
if x in temp_id:
temp_id = temp_id.replace(x, "\{}".format(x))
t_runs = TestRun.search('"{}"'.format(temp_id), fields=["test_run_id", "created", "is_template"],
sort="created",
search_templates=True)
from pylarion.exceptions import PylarionLibException
tr = None
for t in t_runs:
tr = TestRun(uri=t.uri)
try:
if tr.plannedin is not None:
break
except PylarionLibException:
pass
else:
raise Exception("Could not find template")
return tr
def update_test_run(all_cases):
project_name_name = 'RedHatEnterpriseLinux7'
# template_name = 'virtkvmqe-x86-acceptance-rhev-auto'
template_name = 'Empty'
ISOTIMEFORMAT = '%Y-%m-%d %H-%M-%S'
testrun_name = 'virtkvmqe-x86-acceptance ' + time.strftime( ISOTIMEFORMAT, time.gmtime( time.time() ) )
# create a test run
tr = TestRun.create("RedHatEnterpriseLinux7",testrun_name,template_name)
session = TestCase.session
session.tx_begin()
client = session.test_management_client
for case in all_cases:
# for each autocase, create a test record
testcase_record = client.factory.create('tns3:TestRecord')
testcase_record.testCaseURI = ("subterra:data-service:objects:/default/""RedHatEnterpriseLinux7${WorkItem}%s"%case['polarioncase_id'])
testcase_record.duration = case['time']
testcase_record.executed = datetime.datetime.now()
testcase_result = client.factory.create('tns4:EnumOptionId')
testcase_result.id = case['result']
testcase_record.result = testcase_result
# create a comment for each autocase
comment_obj = client.factory.create('tns2:Text')
comment_obj.type = "text/html"
# add the fullname of a autocase
content = case['full_name'] + '\n'
content = content + case['error_info']
comment_obj.content = '<pre>%s</pre>' % content
comment_obj.contentLossy = False
testcase_record.comment = comment_obj
client.service.addTestRecordToTestRun(tr.uri, testcase_record)
# update the test run
session.tx_commit()
def pytest_cmdline_main(config):
if config.getoption('polarion_template') is not None and \
not config.getoption('collectonly'):
fields = {
field.split('=')[0]: field.split('=')[1]
for field in config.getoption('field')
}
# generate TestRun name out of given Fields
# otherwise, adding random 4 chars string as suffix
tr_name = config.getoption('polarion_template')
for f in fields.items():
tr_name += '-{0}_{1}'.format(*f)
if tr_name == config.getoption('polarion_template'):
tr_name += '-random_{}'.format(id_generator())
tr_name = tr_name.replace('.', '_')
tr = TestRun.create(project_id=config.getoption('polarion_project'),
test_run_id=tr_name,
template=config.getoption('polarion_template'))
for k, v in fields.iteritems():
try:
setattr(tr, k, v)
except AttributeError:
print('Failed to set attribute {}={}'.format(k, v))
# tr.build = fields.get('build', '')
tr.update()
config.option.polarion_run = tr_name
def setUpClass(cls):
global TEST_RUN_ID
cls.doc = Document.create(DEFAULT_PROJ, "Testing", DOC_NAME,
"Attribute_Test", ["testcase"],
"testspecification")
cls.testrun = TestRun.create(DEFAULT_PROJ, TEST_RUN_ID, "example",
TEST_RUN_TITLE)
TEST_RUN_ID = cls.testrun.test_run_id
# arch is a custom field defined by global admins for test runs.
# It is set here for a test on custom fields that requires at least two
# valid values. If in the future, this custom field is removed, or the
# number of valid values is lowered to 1, a different custom field will
# have to be used.
valid_values = cls.testrun.get_valid_field_values("arch")
cls.testrun.arch = valid_values[1]
cls.testrun.update()
cls.tc = TestCase.create(DEFAULT_PROJ,
"regression",
"regression",
caseimportance="high",
caselevel="component",
caseautomation="notautomated",
caseposneg="positive",
testtype="functional",
subtype1="-")
cls.TEST_CASE_ID = cls.tc.work_item_id
def collect():
args = parse()
trs = TestRun.search("project.id:{0} AND status:notrun AND isautomated:true".format(args.project_id))
jenkins_url = 'http://{}:{}'.format(args.jenkins, args.jenkins_port)
jenkins_obj = jenkins.Jenkins(jenkins_url, username=args.jenkins_user, password=args.jenkins_pass)
for tr in trs:
jenkins_obj.build_job('PolarionTest', {'PROJECT_ID': args.project_id, 'RUN_ID': tr.test_run_id})
def print_runs_by_query(self, query, is_template=False):
query_ful = 'project.id:%s AND %s' % (TestRun.default_project, query)
fields = [
'query', 'created', 'test_run_id', 'select_test_cases_by',
'status', 'plannedin', 'assignee', 'author'
]
st = TestRun.search(query_ful, fields, 'created', -1, is_template)
Object = ''
if is_template:
Object = 'Template'
prestr = 'Created Time %8sAuthor %3sAssignee' % ('', '')
latstr = '%sStatus %3sPlanID%10s%s' % ('', '', '', Object)
preln = '------------%9s------%4s------' % ('', '')
latln = '%2s--------%2s-------%9s--------' % ('', '', '')
print('%s %s' % (prestr, latstr))
print('%s %s' % (preln, latln))
for tp in st:
created_time = str(tp.created).split('.')[0]
print('%-20s %-9s %-8s %-10s%-15s %s' %
(created_time, tp.author, tp.assignee, tp.status,
tp.plannedin, tp.test_run_id))
def test_010_search_with_custom_fields(self):
"""This test does the following:
* Gets a TestRun
* Searches using the same query as the testrun (adding project id)
* and with custom_field 'plannedin'
* verifies that the 'plannedin' field of the returnd TestRun is None
* The purpose here is to check that it doesnt throws exception
"""
query = "id:%s" % (TEST_RUN_ID)
lst_tr = TestRun.search(query, ["plannedin"])
self.assertEqual(lst_tr[0].plannedin, None)
lst_tr[0].plannedin = self.NEW_PLAN
lst_tr[0].update()
lst_tr = TestRun.search(query, ["plannedin"])
self.assertEqual(lst_tr[0].plannedin, self.NEW_PLAN)
lst_tr[0].plannedin = None
lst_tr[0].update()
def test_013_incident_report_test(self):
"""This test does the following:
* gets a TestRun
* gets a TestCase
* adds test_steps
* creates a TestRecord
* populates the TestRecord
* Fail the testRecord
* reloads the TestCase
* Verifies that an Incident Report was Created
"""
tr = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
tests = [["Test 1", "Result 1"], ["Test 2", "Result 2"],
["Test 3", "Result 3"]]
set_steps = []
for test in tests:
ts = TestStep()
ts.values = test
set_steps.append(ts)
tc = TestCase(work_item_id=self.NEW_TEST_CASE)
tc.set_test_steps(set_steps)
tc.update()
tc.reload()
steps = tc.test_steps.steps
results = []
for step in steps:
res = TestStepResult()
res.result = "failed"
res.comment = "This is the result"
results.append(res)
rec = TestRecord()
rec.test_step_results = results
rec.test_case_id = self.NEW_TEST_CASE
rec.comment = "Incident Report was Created"
rec.duration = "50.5"
rec.result = "failed"
rec.executed_by = tr.logged_in_user_id
rec.executed = datetime.datetime.now()
tr.update_test_record_by_object(self.NEW_TEST_CASE, rec)
tc.reload()
linked_work_items = tc.linked_work_items_derived
idx = len(linked_work_items) - 1
incident = Incident(project_id="proj1",
work_item_id=linked_work_items[idx].work_item_id)
self.assertIsNotNone(incident)
def test_012_search_with_URI_fields(self):
"""This test does the following:
* Gets a TestRun
* Searches using the same query as the testrun (adding project id)
* Verify that 'author' is instantiated
"""
query = "id:%s" % (TEST_RUN_ID)
lst_tr = TestRun.search(query, fields=["author"])
self.assertIsNotNone(lst_tr[0].author)
def test_008_doc_test_run_template(self):
global TEMPLATE_ID
global TEST_RUN_ID
doc_with_space = self.doc_create.space
self.doc_create.session.tx_begin()
tmp = TestRun.create_template(project_id=Document.default_project,
template_id=TEMPLATE_ID,
doc_with_space=doc_with_space,
title=TEMPLATE_TITLE)
TEMPLATE_ID = tmp.test_run_id
tr = TestRun.create(project_id=Document.default_project,
test_run_id=TEST_RUN_ID,
template=TEMPLATE_ID,
title=TEST_RUN_TITLE)
TEST_RUN_ID = tr.test_run_id
self.assertEquals(len(tr.records), 1)
self.assertEquals(tr.records[0].test_case_id, WI_ID)
self.doc_create.session.tx_commit()
def check_for_spare_test_runs_in_excel():
print("Test run in excel but not in Polarion already: ")
test_run_ids = [""]
print(test_run_ids.__len__())
for id in test_run_ids:
test_run = TestRun.search(id)
if not test_run.__len__():
print(id)
def test_004_search(self):
"""This test does the following:
* Gets a TestRun
* Searches using the same query as the testrun (adding project id)
* verifies that there are number of records returned as are in the
records attribute of the TestRun
"""
query = "id:%s" % (TEST_RUN_ID)
lst_tr = TestRun.search(query)
self.assertEqual(lst_tr[0].test_run_id, TEST_RUN_ID)
def test_002_create_run(self):
"""This test does the following:
* creates a test run based on the template created in previous test
* Verifies that the returned object exists and is not a template
"""
global TEST_RUN_ID
tr = TestRun.create(DEFAULT_PROJ, TEST_RUN_ID, TEMPLATE_ID,
TEST_RUN_TITLE)
TEST_RUN_ID = tr.test_run_id
self.assertIsNotNone(tr.test_run_id)
self.assertFalse(tr.is_template)
def test_arr_obj(self):
testrun = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
recs = testrun.records
if not isinstance(recs, list):
recs = []
cnt = 0
else:
cnt = len(recs)
rec = TestRecord()
rec.test_case_id = self.TEST_CASE_ID
rec.executed = datetime.datetime.now()
rec.executed_by = USER
rec.duration = "5.0"
rec.result = "passed"
recs.append(rec)
testrun.records = recs
self.assertEqual(cnt + 1, len(testrun.records))
recs = testrun.records
rec = recs[-1]
self.assertEqual(rec.result, "passed")
def create_test_run_template(self, template_id, case_type="automatedProcess", query=None):
"""
Creates a TestRun template that can be used as a basis for other TestRuns
:param template_id: a unique str to give as ID for this template
:param case_type:
:param query:
:return:
"""
from pylarion.test_run import TestRun
test_template = TestRun.create_template(self.project, template_id, query=query,
select_test_cases_by=case_type)
return test_template
def update_run(self,
run,
template=None,
plannedin=None,
assignee=None,
is_template=False):
qrun = run.replace('-', '\-')
query_ful = 'project.id:%s AND id:%s' % (TestRun.default_project,
qrun.strip())
fields = ['query',
'created',
'test_run_id',
'select_test_cases_by',
'status',
'plannedin',
'assignee',
'author']
st = TestRun.search(query_ful,
fields,
'created',
-1,
is_template)
# Update run if exists, otherwise create it.
if st:
print 'Update the existing run: %s' % run
tr = TestRun(run.strip(),
None,
TestRun.default_project)
else:
tr = TestRun.create(TestRun.default_project,
run.strip(),
template)
print '\nCreated %s:' % run
# set customer filed of plannedin
if plannedin:
tr.plannedin = plannedin
print '%4sSet Plannedin to %s' % ('', plannedin)
if assignee == 'None':
tr.assignee = TestRun.logged_in_user_id
else:
tr.assignee = assignee
print '%4sSet Assignee to %s' % ('', tr.assignee)
tr.update()
def test_run(path, test_run_id, test_template_id, user, project):
"""Execute a test run based on jUnit XML file."""
results = parse_junit(path)
try:
test_run = TestRun(test_run_id, project_id=project)
click.echo('Test run {0} found.'.format(test_run_id))
except PylarionLibException as err:
click.echo(err, err=True)
click.echo('Creating test run {0}.'.format(test_run_id))
test_run = TestRun.create(project, test_run_id, test_template_id)
for result in results:
test_case_id = '{0}.{1}'.format(result['classname'], result['name'])
test_case = TestCase.query(test_case_id)
if len(test_case) == 0:
click.echo(
'Was not able to find test case with id {0}, skipping...'
.format(test_case_id)
)
continue
status = POLARION_STATUS[result['status']]
work_item_id = test_case[0].work_item_id
click.echo(
'Adding test record for test case {0} with status {1}.'
.format(work_item_id, status)
)
try:
test_run.add_test_record_by_fields(
test_case_id=work_item_id,
test_result=status,
test_comment=result.get('message'),
executed_by=user,
executed=datetime.datetime.now(),
duration=float(result.get('time', '0'))
)
except PylarionLibException as err:
click.echo('Skipping test case {0}.'.format(work_item_id))
click.echo(err, err=True)
def print_testcases_from_run(self, run):
tr = TestRun(run, None, TestRun.default_project)
print('(Only CaseID can be displayed when --run=$template)')
print('List cases for: %s\n' % run)
ttstr = ('Created Time %8sStatus %1sExecutedBy %2sCaseID' %
('', '', ''))
lnstr = ('------------%9s------%2s----------%3s------' % ('', '', ''))
print(ttstr)
print(lnstr)
for rec in tr.records:
time = str(rec.executed).split('.')[0]
print('%-21s%-9s%-12s%-10s' %
(time, rec.result, rec.executed_by, rec.test_case_id))
def get_test_run(test_run_id):
"""
Looks for matching TestRun given a test_run_id string
:param test_run_id:
:return:
"""
from pylarion.test_run import TestRun
tr = TestRun.search('"{}"'.format(test_run_id), fields=[u"test_run_id"],
sort="created")
tr = itz.first(tr)
if tr:
tr = TestRun(uri=tr.uri)
return tr
def collect():
args = parse()
trs = TestRun.search(
"project.id:{0} AND status:notrun AND isautomated:true".format(
args.project_id))
jenkins_url = 'http://{}:{}'.format(args.jenkins, args.jenkins_port)
jenkins_obj = jenkins.Jenkins(jenkins_url,
username=args.jenkins_user,
password=args.jenkins_pass)
for tr in trs:
jenkins_obj.build_job('PolarionTest', {
'PROJECT_ID': args.project_id,
'RUN_ID': tr.test_run_id
})
def test_008_update(self):
"""This test does the following:
* gets a TestRun
* modifies an attribute
* updates the TestRun
* reloads the TestRun
* verifies that the TestRun attribute has changed
"""
tr = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
tr.type = "featureverification"
tr.update()
tr.reload()
self.assertEqual(tr.type, "featureverification")
def polarion_collect_items(config):
polarion_run = config.getoption('polarion_run')
polarion_proj = config.getoption('polarion_project')
tr = TestRun(project_id=polarion_proj, test_run_id=polarion_run)
# caching TestRun
config.option.test_run_obj = tr
items = {rec.test_case_id: rec for rec in tr.records}
if not items:
pytest.fail('Failed to collect items from polarion {} run'.format(polarion_run))
# caching test records
config.option.test_run_records = items
return items
def test_011_customfield_object(self):
"""This test does the following:
* gets a TestRun
* Adds a Plan to it
* Verifies that the plan was added
* Verifies that a non valid plan cant be added
"""
tr = TestRun(project_id=DEFAULT_PROJ, test_run_id=TEST_RUN_ID)
with self.assertRaises(PylarionLibException):
tr.plannedin = "not_valid"
tr.plannedin = self.NEW_PLAN
self.assertEquals(tr.plannedin, self.NEW_PLAN)
tr.update()
def get_latest_test_run(test_run_name):
"""
Gets the most recent TestRun based on the test_run_name
NOTE: the test_run_name should be the name of a test run without the integer.
For example, if your TestRun id is normally "Jenkins Run 1", then test_run_name
should be "Jenkins Run".
:param test_run_name: test run id string
:return: TestRun
"""
from pylarion.test_run import TestRun
s = TestRun.search('"{}"'.format(test_run_name),
fields=["test_run_id", "created", "status"],
sort="created")
current = None
if s:
latest = itz.last(s)
current = TestRun(uri=latest.uri)
return current
def test_run(
context, path, source_code_path, test_run_id, test_run_type,
test_template_id, user, custom_fields, project):
"""Execute a test run based on jUnit XML file."""
custom_fields = load_custom_fields(custom_fields)
test_run_id = re.sub(INVALID_CHARS_REGEX, '', test_run_id)
testcases = {
generate_test_id(test): test.tokens.get('id')
for test in itertools.chain(
*testimony.get_testcases([source_code_path]).values()
)
}
results = parse_junit(path)
try:
test_run = TestRun(test_run_id, project_id=project)
click.echo('Test run {0} found.'.format(test_run_id))
except PylarionLibException as err:
click.echo(err, err=True)
click.echo('Creating test run {0}.'.format(test_run_id))
test_run = TestRun.create(
project, test_run_id, test_template_id, type=test_run_type,
**custom_fields)
update = False
if test_run.type != test_run_type:
test_run.type = test_run_type
update = True
for field, value in custom_fields.items():
if getattr(test_run, field) != value:
setattr(test_run, field, value)
click.echo(
'Test Run {0} updated with {1}={2}.'.format(
test_run_id, field, value)
)
update = True
if update:
test_run.update()
OBJ_CACHE['test_run'] = test_run
OBJ_CACHE['user'] = user
OBJ_CACHE['testcases'] = testcases
TestRun.session.tx_begin()
pool = multiprocessing.Pool(context.obj['jobs'])
pool.map(add_test_record, results)
pool.close()
pool.join()
TestRun.session.tx_commit()
def test_run(context, path, test_run_id, test_template_id, user, project):
"""Execute a test run based on jUnit XML file."""
test_run_id = re.sub(INVALID_TEST_RUN_CHARS_REGEX, '', test_run_id)
results = parse_junit(path)
try:
test_run = TestRun(test_run_id, project_id=project)
click.echo('Test run {0} found.'.format(test_run_id))
except PylarionLibException as err:
click.echo(err, err=True)
click.echo('Creating test run {0}.'.format(test_run_id))
test_run = TestRun.create(project, test_run_id, test_template_id)
OBJ_CACHE['test_run'] = test_run
OBJ_CACHE['user'] = user
TestRun.session.tx_begin()
pool = multiprocessing.Pool(context.obj['jobs'])
pool.map(add_test_record, results)
pool.close()
pool.join()
TestRun.session.tx_commit()
def main():
""" This script will create a Test Run with id sys.argv[1] and execute all test cases.
After this script execution complete, the new Test Run should show all test cases passed
and the Test Run status is finished.
argument sys.argv[1]: id name of a new Test Run
"""
PROJECT = "MaistraIstio"
# Creating a Test Run:
tr = TestRun.create(project_id=PROJECT,
test_run_id=sys.argv[1],
template="Build Acceptance type",
title="Istio-Tech-Preview-" + sys.argv[1])
# changing status
tr.status = "inprogress"
# Adding a test record
num_recs = len(tr.records)
print("Number of records: ", num_recs)
sorted_records = sorted(tr.records, key=lambda record: record.test_case_id)
for i in range(num_recs):
tr.update_test_record_by_fields(
test_case_id=sorted_records[i].test_case_id,
test_result="passed",
test_comment="Test case " + sorted_records[i].test_case_id +
" passed smoothly",
executed_by="yuaxu",
executed=datetime.datetime.now(),
duration=150)
print(sorted_records[i].test_case_id + " executed.")
if i % 10 == 0:
tr.reload()
# changing status
tr.status = "finished"
def print_runs_by_query(self, query, is_template=False):
query_ful = 'project.id:%s AND %s' % (TestRun.default_project, query)
fields = ['query',
'created',
'test_run_id',
'select_test_cases_by',
'status',
'plannedin',
'assignee',
'author']
st = TestRun.search(query_ful,
fields,
'created',
-1,
is_template)
Object = ''
if is_template:
Object = 'Template'
prestr = 'Created Time %8sAuthor %3sAssignee' % ('', '')
latstr = '%sStatus %3sPlanID%10s%s' % ('', '', '', Object)
preln = '------------%9s------%4s------' % ('', '')
latln = '%2s--------%2s-------%9s--------' % ('', '', '')
print '%s %s' % (prestr, latstr)
print '%s %s' % (preln, latln)
for tp in st:
created_time = str(tp.created).split('.')[0]
print '%-20s %-9s %-8s %-10s%-15s %s' % (created_time,
tp.author,
tp.assignee,
tp.status,
tp.plannedin,
tp.test_run_id)
def create_test_run(self, template_id, test_run_base=None, runner=None):
"""
Creates a new Polarion TestRun
:param template_id: id of the template to use for TestRun
:param test_run_base: a str to look up most recent TestRuns (eg "Jenkins Run" if
the full name of TestRuns is "Jenkins Run 200"
:param runner: str of the user id (eg stoner, not "Sean Toner")
:return: None
"""
from pylarion.test_run import TestRun
runner = self.get_runner(runner)
tr_temp = self.get_template(template_id)
log.info(tr_temp.plannedin)
for s, testngs in self.tests.items():
if not testngs:
continue
if test_run_base is None:
base_name = self.transformer.generate_base_testrun_id(s)
else:
base_name = test_run_base
# Find our latest run. If it doesn't exist, we'll generate one
tr = get_latest_test_run(base_name)
if tr:
new_id = make_test_run_id_from_latest(tr)
else:
base_name = remove_run(base_name)
new_id = base_name + " Run 1"
log.info("Creating new Test Run ID: {}".format(new_id))
plannedin = self.transformer.config.testrun_plannedin
assignee = self.transformer.config.testrun_assignee
retries = 3
while retries > 0:
retries -= 1
if not plannedin:
if hasattr(tr_temp, "plannedin") and tr_temp.plannedin:
plannedin = tr_temp.plannedin
else:
raise PlannedinException("No plannedin value in template or from config")
if not assignee:
if hasattr(tr_temp, "assignee") and tr_temp.assignee:
assignee = tr_temp.assignee
else:
raise AssigneeException("No assignee value in template or from config")
try:
test_run = TestRun.create(self.project, new_id, template_id, plannedin=plannedin,
assignee=assignee)
break
except PlannedinException as pex:
log.error(pex.message)
raise pex
except AssigneeException as aex:
log.error(aex.message)
raise aex
except Exception as ex:
log.warning("Retrying {} more times".format(retries))
else:
raise Exception("Could not create a new TestRun")
test_run.status = "inprogress"
test_run.variant = [self.transformer.config.distro.variant.lower()]
test_run.jenkinsjobs = self.transformer.config.testrun_jenkinsjobs
test_run.notes = self.transformer.config.testrun_notes
test_run.arch = [self.transformer.config.distro.arch.replace("_", "")]
test_run.group_id = self.transformer.config.testrun_group_id
for tc in testngs:
tc.create_test_record(test_run, run_by=runner)
test_run.status = "finished"
test_run.update()
log.info("Created test run for {}".format(new_id))
