def test_create(self):
tc= TestCase( self.env, dict(zip(TC_KEYS[1:], self.tcvals)) )
for a in self.acdicts:
tc.add_action( TestAction( self.env, a ))
for k, v in zip(TC_KEYS[1:], self.tcvals):
self.assertEqual(v, tc[k])
self.assertEqual(2, len(tc.actions))
def test_find_related_test_case(self):
# simulate test_case creation
test_case = TestCase(contract_hash='f3da12622e9bb2b3f367a650a81fd8c70b2eb495',
transaction_hash='c33fd08be47a978778f1c7098804d8339ce6ec4002e8e7de580552785dca80f5',
event_type='SmartContract.Runtime.Log',
expected_payload_type='String',
expected_payload_value='Contract was called',
active= True
)
self.test_session.add(test_case)
self.test_session.commit()
# simulate receiving a sc_event
sc_event = self.generic_sc_event
sc_event['tx_hash'] = 'c33fd08be47a978778f1c7098804d8339ce6ec4002e8e7de580552785dca80f5'
sc_event['contract_hash'] = 'f3da12622e9bb2b3f367a650a81fd8c70b2eb495'
sc_event['event_type'] = 'SmartContract.Runtime.Log'
sc_event['event_payload']['type'] = 'String'
sc_event['event_payload']['value'] = 'Contract was called'
found_test_case = self.test_session.query(TestCase). \
filter_by(contract_hash=sc_event['contract_hash'], transaction_hash=sc_event['tx_hash'],
event_type=sc_event['event_type'], active=True).first()
self.assertEqual(test_case, found_test_case)
def get(self, project_name, case_name=None):
"""
Get testcases(s) info
:param project_name:
:param case_name:
"""
if case_name is None:
case_name = ""
get_request = dict()
get_request["project_name"] = project_name
if len(case_name) > 0:
get_request["name"] = case_name
res = []
cursor = self.db.test_cases.find(get_request)
print get_request
while (yield cursor.fetch_next):
test_case = TestCase.test_case_from_dict(cursor.next_object())
res.append(test_case.format_http())
meta = dict()
meta["total"] = len(res)
meta["success"] = True if len(res) > 0 else False
answer = dict()
answer["test_cases"] = res
answer["meta"] = meta
self.finish_request(answer)
def add_case():
if not session.get('logged_in'):
abort(401)
tc = TestCase(
request.form['title'],
TestSuite.query.filter(TestSuite.id == request.form['ts_id']).first())
db_session.add(tc)
db_session.commit()
flash('New entry was succesfully posted')
return redirect(url_for('show_cases', ts_id=request.form['ts_id']))
def test_set_status(self):
tc= TestCase( self.env, dict(zip(TC_KEYS[1:], self.tcvals)) )
for a in self.acdicts:
tc.add_action( TestAction( self.env, a ))
tc.insert()
for a in tc.actions:
a.set_status(FAILED, 'dat war wohl nix')
tc.set_status(FAILED)
def tests_parser_v1(self, json):
testData = json['test-cases']
dateRun = parse(str(json['timestamp']))
suite = json['suite-name']
for testcase, data in testData.items():
self.testcase_parser_v1(testcase, data, dateRun, suite)
testCaseId = TestCase.gettestcaseid(testcase, dateRun)
for test in data:
testName = test["test-name"]
testMessage = test["message"]
testResult = test["result"]
if not Test.isdupe(testName, testCaseId):
db.session.add(Test(TestCaseId=testCaseId, TestName=testName, Message=testMessage, Result=testResult))
db.session.commit()
else:
pass
def test_test_case_creation(self):
# directly create test into the database
test_case = TestCase(contract_hash='f3da12622e9bb2b3f367a650a81fd8c70b2eb495',
transaction_hash='c33fd08be47a978778f1c7098804d8339ce6ec4002e8e7de580552785dca80f5',
event_type='SmartContract.Runtime.Log',
expected_payload_type='String',
expected_payload_value='Contract was called',
active= True
)
self.test_session.add(test_case)
self.test_session.commit()
t_case = self.test_session.query(TestCase).filter_by(
contract_hash='f3da12622e9bb2b3f367a650a81fd8c70b2eb495',
transaction_hash='c33fd08be47a978778f1c7098804d8339ce6ec4002e8e7de580552785dca80f5',
event_type='SmartContract.Runtime.Log').first()
self.assertEqual(test_case, t_case)
def writeData(request, file_path):
project_name = readRowsData(file_path)[0][1]
for test_case in readRowsData(file_path)[2:]:
TestCase(
project_name=project_name,
number=test_case[0],
function_model=test_case[1],
title=test_case[2],
precondition=test_case[3],
procedure=test_case[4],
ex_result=test_case[5],
#pr_result=test_case[6],
#test_result=test_case[7],
grade=test_case[8],
create_user=request.session.get("username"),
modify_user=request.session.get("username")).save()
def put(self, project_name, case_name):
"""
Updates the name and description of a test case
:raises HTTPError (HTTP_NOT_FOUND, HTTP_FORBIDDEN)
"""
print "PUT request for : {}/{}".format(project_name, case_name)
case_request = {"project_name": project_name, "name": case_name}
# check if there is a case for the project in url parameters
mongo_dict = yield self.db.test_cases.find_one(case_request)
test_case = TestCase.test_case_from_dict(mongo_dict)
if test_case is None:
raise HTTPError(
HTTP_NOT_FOUND, "{} could not be found as a {} case to be updated".format(case_name, project_name)
)
new_name = self.json_args.get("name")
new_project_name = self.json_args.get("project_name")
new_description = self.json_args.get("description")
# check if there is not an existing test case
# with the name provided in the json payload
mongo_dict = yield self.db.test_cases.find_one({"project_name": new_project_name, "name": new_name})
if mongo_dict is not None:
raise HTTPError(HTTP_FORBIDDEN, "{} already exists as a project".format(new_name))
# new dict for changes
request = dict()
request = prepare_put_request(request, "name", new_name, test_case.name)
request = prepare_put_request(request, "project_name", new_project_name, test_case.project_name)
request = prepare_put_request(request, "description", new_description, test_case.description)
# we raise an exception if there isn't a change
if not request:
raise HTTPError(HTTP_FORBIDDEN, "Nothing to update")
# we merge the whole document """
edit_request = test_case.format()
edit_request.update(request)
""" Updating the DB """
res = yield self.db.test_cases.update(case_request, edit_request)
print res
edit_request["_id"] = str(test_case._id)
self.finish_request({"message": "success", "content": edit_request})
def test_success_should_eql_true(self):
# simulate test_case creation
t_case = TestCase(contract_hash='f3da12622e9bb2b3f367a650a81fd8c70b2eb495',
transaction_hash='c33fd08be47a978778f1c7098804d8339ce6ec4002e8e7de580552785dca80f5',
event_type='SmartContract.Runtime.Log',
expected_payload_type='String',
expected_payload_value='Contract was called',
active= True
)
self.test_session.add(t_case)
self.test_session.commit()
# simulate receiving a sc_event
sc_event = self.generic_sc_event
sc_event['tx_hash'] = 'c33fd08be47a978778f1c7098804d8339ce6ec4002e8e7de580552785dca80f5'
sc_event['contract_hash'] = 'f3da12622e9bb2b3f367a650a81fd8c70b2eb495'
sc_event['event_type'] = 'SmartContract.Runtime.Log'
sc_event['event_payload']['type'] = 'String'
sc_event['event_payload']['value'] = 'Contract was called'
# simulates handle event function from tasks
found_test_case = self.test_session.query(TestCase). \
filter_by(contract_hash=sc_event['contract_hash'], transaction_hash=sc_event['tx_hash'],
event_type=sc_event['event_type'], active=True).first()
# simulates evaluate function from tasks
test_case = self.test_session.query(TestCase).get(found_test_case.id)
if not test_case.success:
sc_event_payload = sc_event['event_payload']
if sc_event['event_type'] == test_case.event_type.value and sc_event_payload['type'] == test_case.\
expected_payload_type.value:
if str(sc_event_payload['value']) == test_case.expected_payload_value:
test_case.sc_event = json.dumps(sc_event)
test_case.active = False
test_case.success = True
else:
test_case.sc_event = json.dumps(sc_event)
test_case.active = False
test_case.success = False
self.assertEqual(test_case.active, False)
self.assertEqual(test_case.success, True)
def post(self, project_name):
""" Create a test case"""
print "POST Request for {}".format(project_name)
if self.json_args is None:
raise HTTPError(HTTP_BAD_REQUEST, "Check your request payload")
# retrieve test project
mongo_dict = yield self.db.test_projects.find_one({"name": project_name})
if mongo_dict is None:
raise HTTPError(HTTP_FORBIDDEN, "Could not find project {}".format(project_name))
# test_project = TestProject.testproject_from_dict(self.json_args)
case = TestCase.test_case_from_dict(self.json_args)
case.project_name = project_name
case.creation_date = datetime.now()
future = self.db.test_cases.insert(case.format())
result = yield future
case._id = result
self.finish_request(case.format_http())
def testcase_parser_v1(self, name, data, date, suite):
caseName = name
dateRun = date
suiteId = Suite.getsuiteid(suite, dateRun)
testResults = [0, 0, 0, 0] # pass, fail, error, skip
for test in data:
if self.is_result_valid(test["result"]):
if test["result"] == "passed":
testResults[0] += 1
elif test["result"] == "failure":
testResults[1] += 1
elif test["result"] == "error":
testResults[2] += 1
else:
testResults[3] += 1
testPass, testFail, testError, testSkip = testResults
testCount = sum(testResults)
if not TestCase.isdupe(caseName, dateRun):
db.session.add(TestCase(SuiteId=suiteId, TestCaseName=caseName, TestCount=testCount,
PassCount=testPass, FailCount=testFail, ErrorCount=testError,
SkipCount=testSkip, DateRun=dateRun))
db.session.commit()
else:
pass
def createTestCase(request):
if request.method == 'POST':
form = CreateTestCaseForm(request.POST)
# 验证数据的合法性
if form.is_valid():
# 如果提交数据合法，调用表单的 save 方法将数据保存到数据库
TestCase(project_name=request.POST["project_name"],
number=request.POST["number"],
function_model=request.POST["function_model"],
title=request.POST["title"],
precondition=request.POST["precondition"],
procedure=request.POST["procedure"],
grade=request.POST["grade"],
test_result="未测试",
create_user=request.session.get("username"),
modify_user=request.session.get("username")).save()
# 创建成功，跳转回首页
return HttpResponseRedirect('/testadmin/testCase')
else:
form = CreateDatabaseInfoForm()
return render(request, "testadmin/create_testcase.html", {
'form': form,
'post': request.POST
})
def post(self,request):
project_id = int(request.COOKIES["p_id"])
# 操作外键的的时候，必须要先实例化外键对应的mode
if project_id != '':
belong_project_id = ProjectInfo.objects.get(id=int(project_id))
case_info = TestCase()
name = request.POST.get("name", "")
parent_area = int(request.POST.get("pId", ""))
type = request.POST.get("type","")
designer = request.user.username
if type == 'ml'and parent_area > 0:
# print(parent_area,type,name)
case_info.name = name
case_info.type = type
case_info.belong_project = belong_project_id
case_info.parent_id = parent_area
case_info.designer = designer
case_info.save()
id = case_info.id
# print(case_info.id,case_info.name,case_info.parent_area_id)
return JsonResponse({"msg": "新增节点成功","code": 200,'id': id})
elif type == 'ml'and parent_area == 0:
case_info.name = name
case_info.type = type
case_info.belong_project = belong_project_id
case_info.designer = designer
case_info.save()
id = case_info.id
# print(case_info.id,case_info.name,case_info.parent_area_id)
return JsonResponse({"msg": "新增根节点成功", "code": 200, 'id': id})
elif type == 'yl':
jb = request.POST.get("jb", "")
precondition = request.POST.get("precondition", "")
operation = request.POST.get("operation", "")
expect_result = request.POST.get("expect_result", "")
case_desc = request.POST.get("case_desc", "")
case_info.belong_project = belong_project_id
case_info.name = name
case_info.parent_id = parent_area
case_info.type = type
case_info.jb = jb
case_info.precondition = precondition
case_info.operation = operation
case_info.expect_result = expect_result
case_info.case_desc = case_desc
case_info.designer = designer
case_info.save()
return JsonResponse({"msg": "新增用例成功", "code": 200})
else:
return JsonResponse({"msg": "p_id不能为空", "code": 500})
def parse_results_to_jira(url, key, username, password, result_path, issueType = "Bug", environment = "DEV", assignee = ""):
jira = core.create_jira_connection(url, username, password)
xmlGlob = glob.glob("{0}/*.xml".format(result_path))
testResults = ParseResults()
#HN DEBUG:
print("xmlGlob:", len(xmlGlob), flush=True)
for xml in xmlGlob:
result = ET.parse(xml).getroot()
for testCase in result.iter('testcases'):
if testCase.find('error') is not None or testCase.find('Failure') is not None:
testResults.testcases.append(TestCase.generate_testcase_object(
environment,
testCase.attrib.get('classname'),
testCase.attrib.get('name'),
testCase.find('error').attrib.get('type') if testCase.find('error') is not None else testCase.find('Failure').get('type'),
testCase.find('error').text if testCase.find('error') is not None else testCase.find('Failure').text
))
else:
testResults.testcases.append(TestCase.generate_testcase_object(
environment,
testCase.attrib.get('classname'),
testCase.attrib.get('name')
))
continue
#HN DEBUG:
print("testResults.testcases", len(testResults.testcases), flush=True)
for testcase in testResults.testcases:
existingIssues = core.check_for_existing_jira_issue(jira, testcase.title, key, issueType)
if testcase.description is not None:
print("existingIssues.count:", existingIssues.count, flush=True)
if existingIssues.count > 0:
jira.add_comment(
existingIssues.results[0],
"h2. {0}: Test Case Additional Fail\n\n{{code:borderStyle=solid}}{1}{{code}}".format(datetime.datetime.today().strftime("%Y.%m.%d %H:%M"),testcase.description)
)
testResults.updatedCount +=1
else:
core.create_jira_issue(jira, testcase, key, issueType, environment, assignee)
testResults.createdCount +=1
else:
#HN DEBUG:
print("testcase.description:", testcase.description, flush=True)
print("existingIssues.count:", existingIssues.count, flush=True)
if existingIssues.count > 0:
for issue in existingIssues.results:
jira.transition_issue(
jira.issue(issue),
#T000: Set up ENUM for Resolution states on defferent issue types, just in case
'2',
fields={
'resolution':{'name':'Closed'}
}
)
testResults.resolvedCount +=1
existingIssues.results.clear()
existingIssues.count = 0
print("""
JIRA - PROJECT: {0} ({1})
-------------------------------
Defects Created: {2}
Defects Updated: {3}
Defects Closed: {4}
""".format(
jira.project(key).name,
key,
testResults.createdCount,
testResults.updatedCount,
testResults.resolvedCount
)
)
return True
def test_insert(self):
tc= TestCase( self.env, dict(zip(TC_KEYS[1:], self.tcvals)) )
for a in self.acdicts:
tc.add_action( TestAction( self.env, a ))
self.assertTrue(tc.insert() is not None)
