class TestLinkAPIOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """

    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIClient)


#    def tearDown(self):
#        pass


    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)
        
    def test_about(self):
        response = self.client.about()
        self.assertIn('Testlink API', response)

    def test_ping(self):
        response = self.client.ping()
        self.assertEqual('Hello!', response)

    def test_echo(self):
        response = self.client.echo('Yellow Submarine')
        self.assertEqual('You said: Yellow Submarine', response)
        
    def test_doesUserExist_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '10000.*Big Bird'):
            self.client.doesUserExist('Big Bird')
        
    def test_getBuildsForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getBuildsForTestPlan(4711)
        
    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getFirstLevelTestSuitesForTestProject(4711)

    def test_getFullPath_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, 'getFullPath.*234'):
            self.client.getFullPath('4711')

    def test_getLastExecutionResult_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getLastExecutionResult(4711, 4712)
        
    def test_getLatestBuildForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getLatestBuildForTestPlan(4711)
        
    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)
        
    def test_getProjectTestPlans_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getProjectTestPlans(4711)

    def test_getProjectPlatforms_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getProjectPlatforms(4711)
        
    def test_getTestCase_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.getTestCase(4711)
        
    def test_getTestCase_unknownExternalID(self):
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-2'):
            self.client.getTestCase(testcaseexternalid='N-2')
        
    def test_getTestCaseAttachments_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.getTestCaseAttachments(4711)
        
    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getTestCaseCustomFieldDesignValue(
                   'TC-4712', 1, 4711, 'a_field', 'a_detail')
        
    def test_getTestCaseIDByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5030.*Cannot find'):
            self.client.getTestCaseIDByName('Big Bird')

    def test_getTestCasesForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestCasesForTestPlan(4711)

    def test_getTestCasesForTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestCasesForTestSuite(4711, 2, 'a_detail')

    def test_getTestPlanByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.getTestPlanByName('project 4711', 'plan 4712')

    def test_getTestPlanPlatforms_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestPlanPlatforms(4711)

    def test_getTestProjectByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.getTestProjectByName('project 4711')

    def test_getTestSuiteByID_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestSuiteByID(4711)

    def test_getTestSuitesForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestSuitesForTestPlan(4711)

    def test_getTestSuitesForTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestSuitesForTestSuite(4711)

    def test_getTotalsForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTotalsForTestPlan(4711)

    def test_createTestProject_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7001.*Empty name'):
            self.client.createTestProject('', 'P4711')

    def test_createBuild_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.createBuild(4711, 'Build 4712', 'note 4713')

    def test_createTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4712'):
            self.client.createTestPlan('plan 4711', 'project 4712')

    def test_createTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.createTestSuite( 4711, 'suite 4712', 'detail 4713')

    def test_createTestCase_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4713'):
            self.client.createTestCase('case 4711', 4712, 4713, 
                                               'Big Bird', 'summary 4714')

    def test_reportTCResult_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.reportTCResult(4711, 4712, 'build 4713', 'p', 
                                              'note 4714')

    def test_uploadExecutionAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadExecutionAttachment(attachemantFile, 4712, 
                        'title 4713', 'descr. 4714')

    def test_getProjectIDByName_unknownID(self):
        response = self.client.getProjectIDByName('project 4711')
        self.assertEqual(-1, response)
        
    def test_createPlatform_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.createPlatform('Project 4711', 'Platform 4712', 
                                       notes='note 4713')
        
    def test_addTestCaseToTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.addTestCaseToTestPlan(4711, 4712, 'N-4713', 1)
            
    def test_updateTestCase_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-4711'):
            self.client.updateTestCase('N-4711', version=1)

    def test_createTestCaseSteps_unknownID(self):
        steps = [{'actions' : "Step action 6 -b added by updateTestCase" , 
                  'expected_results' : "Step result 6 - b added", 
                  'step_number' : 6, 'execution_type' : 1}]
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-4711'):
            self.client.createTestCaseSteps('update', steps, 
                                        testcaseexternalid='N-4711', version=1)
            
    def test_deleteTestCaseSteps_unknownID(self):
        steps = [2,8]
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-4711'):
            self.client.deleteTestCaseSteps('N-4711', steps, version=1)

    def test_uploadRequirementSpecificationAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadRequirementSpecificationAttachment(attachemantFile, 4712, 
                        title='title 4713', description='descr. 4714')
 
    def test_uploadRequirementAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadRequirementAttachment(attachemantFile, 4712, 
                        title='title 4713', description='descr. 4714')
 
    def test_uploadTestProjectAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '7000.*4712'):
            self.client.uploadTestProjectAttachment(attachemantFile, 4712, 
                        title='title 4713', description='descr. 4714')
 
    def test_uploadTestSuiteAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '8000.*4712'):
            self.client.uploadTestSuiteAttachment(attachemantFile, 4712, 
                        title='title 4713', description='descr. 4714')
 
    def test_uploadTestCaseAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '5000.*testcaseid'):
            self.client.uploadTestCaseAttachment(attachemantFile, 4712, 
                        title='title 4713', description='descr. 4714')
 
    def test_uploadAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadAttachment(attachemantFile, 4712, 'nodes_hierarchy',
                        title='title 4713', description='descr. 4714')

    def test_testLinkVersion(self):
        response = self.client.testLinkVersion()
        self.assertRegexpMatches(response, '\d*\.\d*\.\d*')

    def test_getUserByLogin_unknownKey(self):
        with self.assertRaisesRegexp(TLResponseError, '10000.*User Login'):
            self.client.getUserByLogin(user='******')
            
#     def test_setTestMode(self):
#         response = self.client.setTestMode(True)
#         self.assertTrue(response)
#         response = self.client.setTestMode(False)
#         self.assertTrue(response)
            
    def test_deleteExecution_unknownKey(self):
        try:
            response = self.client.deleteExecution(4711)
            # case: TL configuration allows deletion of executions
            # response returns Success, even if executionID is unkown
            self.assertEqual([{'status': True, 'message': 'Success!', 'id': 4711, 
                               'operation': 'deleteExecution'}], response)
        except TLResponseError as tl_err:
            # case: TL configuration does not allow deletion of executions
            # Expects: 232: Configuration does not allow delete executions
            self.assertEqual(232, tl_err.code)
            
    def test_setTestCaseExecutionType_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4712'):
            self.client.setTestCaseExecutionType('N-4711', 1, 4712, 1)

    def test_assignRequirements_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4712'):
            self.client.assignRequirements('N-4711', 4712, 
                        [{'req_spec' : 4713, 'requirements' : [4714, 4717]}, 
                         {'req_spec' : 4723, 'requirements' : [4725]}])
            
    def test_getExecCountersByBuild_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getExecCountersByBuild(4711)

    def test_assignTestCaseExecutionTask_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.assignTestCaseExecutionTask('username', 4711, 'TC-4712', 
                                            buildname='build 4713', 
                                            platformname='platform 4714')                         
            
    def test_getTestCaseBugs_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestCaseBugs(4711, testcaseexternalid='TC-4712', 
                                        buildname='build 4713',
                                        platformname='platform 4714')                         
                                  
    def test_getTestCaseAssignedTester_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestCaseAssignedTester(4711, 'TC-4712', 
                                            buildname='build 4713', 
                                            platformname='platform 4714') 
	platformName = sys.argv[4]
	robot_result_path = sys.argv[5]
	result_map = getTestResultMap(robot_result_path)
	#prepare to upload test result
	tlapi = TestLinkHelper().connect(TestlinkAPIClient)
	#get testplan id
	testplan_res = tlapi.getTestPlanByName(projName, testPlanName)
	if len(testplan_res) != 1 :
		raise Exception('Find %s testplan(%s) in project(%s)'%(len(testplan_res), testPlanName, projName))
	if not testplan_res[0].has_key('id'):
		raise Exception('Did not find testplan(%s) id!')
	testplan_id = testplan_res[0]['id']
	#get platforms
	platform_id = ''
	if platformName != 'no_platform':
		platform_list = tlapi.getTestPlanPlatforms(testplan_id)
		#[{'notes': '<p>\n\tCPMS+PAB+CAL+CPDS+FS</p>', 'id': '240', 'name': 'Fusion-CPMS Backend'}, {'notes': '<p>\n\tMX+PAB+CAL+mOS+SUR</p>', 'id': '241', 'name': 'Fusion-MX Backend'}]
		for platform in platform_list:
			if platform['name'] == platformName:
				platform_id = platform['id']
		if platform_id == '':
			raise Exception('Can not found platform(%s) id!'%platform_id)
	else:
		platform_id = 'no_platform'

	#create new build if necessary
	build_list = tlapi.getBuildsForTestPlan(testplan_id)
	need_create_new_build = True
	for each_build in build_list:
		if buildName == each_build['name']:
			need_create_new_build = False
class TestLinkAPIGenericOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """

    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIGeneric)

#    def tearDown(self):
#        pass

    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)
        
    def test_checkDevKey_unknownKey(self):
        with self.assertRaisesRegex(TLResponseError, '2000.*invalid'):
            self.client.checkDevKey(devKey='unknownKey')
        
    def test_sayHello(self):
        response = self.client.sayHello()
        self.assertEqual('Hello!', response)

    def test_repeat(self):
        response = self.client.repeat('Yellow Submarine')
        self.assertEqual('You said: Yellow Submarine', response)
        
    def test_about(self):
        response = self.client.about()
        self.assertIn('Testlink API', response)

    def test_doesUserExist_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '10000.*Big Bird'):
            self.client.doesUserExist('Big Bird')
        
    def test_createTestProject_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7001.*Empty name'):
            self.client.createTestProject(testprojectname='', 
                                                 testcaseprefix='P40000711')
 
    def test_createTestProject_unknownITS(self):
        with self.assertRaisesRegex(TLResponseError, '13000.*Unable to find'):
            self.client.createTestProject(testprojectname='aProject', 
                                testcaseprefix='aPrefix', itsname='unknownITS')
 
    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)
         
    def test_createTestPlan_projectname_posArg_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7011.*40000712'):
            self.client.createTestPlan('plan 40000711', 'project 40000712')
 
    def test_createTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.createTestSuite( 40000711, 'suite 40000712', 'detail 40000713')
        
    def test_createTestCase_unknownID(self):
        tc_steps = []
        with self.assertRaisesRegex(TLResponseError, '7000.*40000713'):
            self.client.createTestCase('case 40000711', 40000712, 40000713, 
                                        'Big Bird', 'summary 40000714', tc_steps)
 
    def test_getBuildsForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getBuildsForTestPlan(40000711)
         
    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getFirstLevelTestSuitesForTestProject(40000711)
 
    def test_getFullPath_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, 'getFullPath.*234'):
            self.client.getFullPath('40000711')
 
    def test_getLastExecutionResult_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getLastExecutionResult(40000711, testcaseid=40000712)
         
    def test_getLatestBuildForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getLatestBuildForTestPlan(40000711)
         
    def test_getProjectTestPlans_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getProjectTestPlans(40000711)
         
    def test_getProjectPlatforms_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getProjectPlatforms(40000711)
        
    def test_getTestCase_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5000.*40000711'):
            self.client.getTestCase(testcaseid=40000711)
         
    def test_getTestCase_unknownExternalID(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*GPROAPI-40000711'):
            self.client.getTestCase(testcaseexternalid='GPROAPI-40000711')
            
    def test_getTestCaseAttachments_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5000.*40000711'):
            self.client.getTestCaseAttachments(testcaseid=40000711)
         
    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getTestCaseCustomFieldDesignValue(
                   'TC-40000712', 1, 40000711, 'a_field', details='full')
         
    def test_getTestCaseIDByName_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5030.*Cannot find'):
            self.client.getTestCaseIDByName('Big Bird')
 
    def test_getTestCasesForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getTestCasesForTestPlan(40000711)
 
    def test_getTestCasesForTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '8000.*40000711'):
            self.client.getTestCasesForTestSuite(40000711)
 
    def test_getTestPlanByName_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7011.*40000711'):
            self.client.getTestPlanByName('project 40000711', 'plan 40000712')
 
    def test_getTestPlanPlatforms_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getTestPlanPlatforms(40000711)
 
    def test_getTestProjectByName_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7011.*40000711'):
            self.client.getTestProjectByName('project 40000711')
 
    def test_getTestSuiteByID_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '8000.*40000711'):
            self.client.getTestSuiteByID(40000711)
 
    def test_getTestSuitesForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getTestSuitesForTestPlan(40000711)
 
    def test_getTestSuitesForTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '8000.*40000711'):
            self.client.getTestSuitesForTestSuite(40000711)
 
    def test_getTotalsForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getTotalsForTestPlan(40000711)
 
    def test_createBuild_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.createBuild(40000711, 'Build 40000712', buildnotes='note 40000713')
 
    def test_reportTCResult_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5000.*40000711'):
            self.client.reportTCResult(40000712, 'p', testcaseid=40000711, 
                                       buildname='build 40000713', notes='note 40000714' )
 
    def test_uploadExecutionAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegex(TLResponseError, '6004.*40000712'):
            self.client.uploadExecutionAttachment(attachemantFile, 40000712, 
                        title='title 40000713', description='descr. 40000714')
 
    def test_createPlatform_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7011.*40000711'):
            self.client.createPlatform('Project 40000711', 'Platform 40000712', 
                                       notes='note 40000713')
            
    def test_addPlatformToTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.addPlatformToTestPlan(40000711, 'Platform 40000712')
            
    def test_removePlatformFromTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.removePlatformFromTestPlan(40000711, 'Platform 40000712')
            
    def test_addTestCaseToTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.addTestCaseToTestPlan(40000711, 40000712, 'N-40000713', 1)
            
    def test_updateTestCase_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*N-40000711'):
            self.client.updateTestCase('N-40000711', version=1)
        
    def test_createTestCaseSteps_unknownID(self):
        steps = [{'actions' : "Step action 6 -b added by updateTestCase" , 
                  'expected_results' : "Step result 6 - b added", 
                  'step_number' : 6, 'execution_type' : 1}]
        with self.assertRaisesRegex(TLResponseError, '5040.*N-40000711'):
            self.client.createTestCaseSteps('update', steps, 
                                        testcaseexternalid='N-40000711', version=1)
            
    def test_deleteTestCaseSteps_unknownID(self):
        steps = [2,8]
        with self.assertRaisesRegex(TLResponseError, '5040.*N-40000711'):
            self.client.deleteTestCaseSteps('N-40000711', steps, version=1)
            
    def test_uploadRequirementSpecificationAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r')
        with self.assertRaisesRegex(TLResponseError, '6004.*40000712'):
            self.client.uploadRequirementSpecificationAttachment(attachemantFile, 40000712, 
                        title='title 40000713', description='descr. 40000714')
 
    def test_uploadRequirementAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r')
        with self.assertRaisesRegex(TLResponseError, '6004.*40000712'):
            self.client.uploadRequirementAttachment(attachemantFile, 40000712, 
                        title='title 40000713', description='descr. 40000714')
 
    def test_uploadTestProjectAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r')
        with self.assertRaisesRegex(TLResponseError, '7000.*40000712'):
            self.client.uploadTestProjectAttachment(attachemantFile, 40000712, 
                        title='title 40000713', description='descr. 40000714')
 
    def test_uploadTestSuiteAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r')
        with self.assertRaisesRegex(TLResponseError, '8000.*40000712'):
            self.client.uploadTestSuiteAttachment(attachemantFile, 40000712, 
                        title='title 40000713', description='descr. 40000714')
 
    def test_uploadTestCaseAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r')
        with self.assertRaisesRegex(TLResponseError, '5000.*testcaseid'):
            self.client.uploadTestCaseAttachment(attachemantFile, 40000712, 
                        title='title 40000713', description='descr. 40000714')
 
    def test_uploadAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, 'r')
        with self.assertRaisesRegex(TLResponseError, '6004.*Invalid Foreign Key ID'):
            self.client.uploadAttachment(attachemantFile, '0000', 'nodes_hierarchy',
                        title='title 40000713', description='descr. 40000714')

    def test_testLinkVersion(self):
        response = self.client.testLinkVersion()
        self.assertRegex(response, '\d*\.\d*\.\d*')

    def test_getUserByLogin_unknownKey(self):
        with self.assertRaisesRegex(TLResponseError, '10000.*User Login'):
            self.client.getUserByLogin('unknownUser')
            
    def test_getUserByID_unknownKey(self):
         with self.assertRaisesRegex(TLResponseError, 'NO_USER_BY_ID_LOGIN.*User with DB ID'):
            self.client.getUserByID(40000711)
            
#     def test_setTestMode(self):
#         response = self.client.setTestMode(True)
#         self.assertTrue(response)
#         response = self.client.setTestMode(False)
#         self.assertTrue(response)

    def test_deleteExecution_unknownKey(self):
        try:
            response = self.client.deleteExecution(40000711)
            # case: TL configuration allows deletion of executions
            # response returns Success, even if executionID is unkown
            self.assertEqual([{'status': True, 'message': 'Success!', 'id': 40000711, 
                               'operation': 'deleteExecution'}], response)
        except TLResponseError as tl_err:
            # case: TL configuration does not allow deletion of executions
            # Expects: 232: Configuration does not allow delete executions
            self.assertEqual(232, tl_err.code)

    def test_setTestCaseExecutionType_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000712'):
            self.client.setTestCaseExecutionType('N-40000711', 1, 40000712, 1)
            
    def test_assignRequirements_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000712'):
            self.client.assignRequirements('N-40000711', 40000712, 
                        [{'req_spec' : 40000713, 'requirements' : [40000714, 40000717]}, 
                         {'req_spec' : 4723, 'requirements' : [4725]}])
            
    def test_getExecCountersByBuild_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getExecCountersByBuild(40000711)
            
    def test_getTestCaseCustomFieldExecutionValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '236.*version/executionid'):
            self.client.getTestCaseCustomFieldExecutionValue(
                            'cf_full', '40000711', 1, '715', '40000713')
            
    def test_getTestCaseCustomFieldTestPlanDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getTestCaseCustomFieldTestPlanDesignValue(
                            'cf_full', '40000711', 1, '40000713', '615')
            
    def test_updateTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.updateTestCaseCustomFieldDesignValue(
                            'TC-40000712', 1, 40000711, {'cf_field1' : 'value1',
                                                 'cf_field2' : 'value2'})

    def test_getTestSuiteCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getTestSuiteCustomFieldDesignValue(
                                                    'cf_full', 40000711, 40000713) 
            
    def test_getTestPlanCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getTestPlanCustomFieldDesignValue(
                                                    'cf_full', 40000711, 40000712)             

    def test_getReqSpecCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getReqSpecCustomFieldDesignValue(
                                                    'cf_full', 40000711, 4732)             

    def test_getRequirementCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getRequirementCustomFieldDesignValue(
                                                    'cf_full', 40000711, 4734)  
            
    def test_assignTestCaseExecutionTask_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.assignTestCaseExecutionTask('username', 40000711, 'TC-40000712', 
                                            buildname='build 40000713', 
                                            platformname='platform 40000714') 
              
    def test_getTestCaseBugs_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getTestCaseBugs(40000711, testcaseexternalid='TC-40000712', 
                                        buildname='build 40000713',
                                        platformname='platform 40000714')                         

    def test_getTestCaseAssignedTester_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.getTestCaseAssignedTester(40000711, 'TC-40000712', 
                                            buildname='build 40000713', 
                                            platformname='platform 40000714') 
              
    def test_unassignTestCaseExecutionTask_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.unassignTestCaseExecutionTask(40000711, 'TC-40000712', 
                                        buildname='build 40000713', 
                                        platformname='platform 40000714',
                                        user='******',action='unassignOne') 
    
    def test_getProjectKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.getProjectKeywords(40000711) 

    def test_getTestCaseKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*40000712'):
            self.client.getTestCaseKeywords(testcaseid=40000712) 

    def test_getTestCaseKeywords_unknownID_set(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*40000712'):
            self.client.getTestCaseKeywords(testcaseid=[40000712, 40000713]) 

    def test_getTestCaseKeywords_unknownID_external_single(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*TC-40000712'):
            self.client.getTestCaseKeywords(testcaseexternalid='TC-40000712')
            
    def test_getTestCaseKeywords_unknownID_external_set(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*TC-40000712'):
            self.client.getTestCaseKeywords(testcaseexternalid=['TC-40000712', 'TC-40000713'])

    def test_deleteTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '3000.*40000711'):
            self.client.deleteTestPlan(40000711) 

    def test_addTestCaseKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*TC-40000712'):
            self.client.addTestCaseKeywords({'TC-40000712' :  
                                             ['KeyWord01', 'KeyWord03']}) 

    def test_removeTestCaseKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '5040.*TC-40000712'):
            self.client.removeTestCaseKeywords({'TC-40000712' : ['KeyWord01']}) 

    def test_deleteTestProject_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7013.*TProjectPrefix'):
            self.client.deleteTestProject('TProjectPrefix') 

    def test_createTestPlan_projectname_optArg_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7011.*40000712'):
            self.client.createTestPlan('plan 40000711', 
                                       testprojectname='project 40000712')

    def test_createTestPlan_prefix_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, 'NO.*TProjectPrefix'):
            self.client.createTestPlan('plan 40000713', 
                                       prefix='TProjectPrefix')

    def test_updateTestSuiteCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000712'):
            self.client.updateTestSuiteCustomFieldDesignValue(
                            '40000712 TP-ID', '40000711 TS-ID',  
                            {'cf_tc_ex_string' : 'a custom exec value', 
                             'cf_tc_ex_numeric' : 111} )

    def test_getTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, 'NO.*TProjectPrefix'):
            self.client.getTestSuite('suite 40000712', 'TProjectPrefix')
            

    def test_updateTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000711'):
            self.client.updateTestSuite(40000712, testprojectid=40000711, 
                                    testsuitename = 'suite 40000712 updated',
                                    details = 'detail 40000713 updated',
                                    order =1)
            
    def test_getIssueTrackerSystem_unknownITS(self):
        with self.assertRaisesRegex(TLResponseError, '13000.*Unable to find'):
            self.client.getIssueTrackerSystem('unknownITS')
 
    def test_updateBuildCustomFieldsValues_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, '7000.*40000712'):
            self.client.updateBuildCustomFieldsValues(
                            '40000712 project', '40000713 plan', '40000714 build', 
                            {'cf_b_ex_string' : 'a custom exec value', 
                             'cf_b_ex_numeric' : 111} )
class TestLinkAPIOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """

    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIClient)


#    def tearDown(self):
#        pass


    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)
        
    def test_about(self):
        response = self.client.about()
        self.assertIn('Testlink API', response)

    def test_ping(self):
        response = self.client.ping()
        self.assertEqual('Hello!', response)

    def test_echo(self):
        response = self.client.echo('Yellow Submarine')
        self.assertEqual('You said: Yellow Submarine', response)
        
    def test_doesUserExist_unknownID(self):
        response = self.client.doesUserExist('Big Bird')
        self.assertIn('Big Bird', response[0]['message'])
        self.assertEqual(10000, response[0]['code'])
        
    def test_getBuildsForTestPlan_unknownID(self):
        response = self.client.getBuildsForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])
        
    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        response = self.client.getFirstLevelTestSuitesForTestProject(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_getFullPath_unknownID(self):
        response = self.client.getFullPath(4711)
        self.assertIn('getFullPath', response[0]['message'])
        self.assertEqual(234, response[0]['code'])

    def test_getLastExecutionResult_unknownID(self):
        response = self.client.getLastExecutionResult(4711, 4712)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])
        
    def test_getLatestBuildForTestPlan_unknownID(self):
        response = self.client.getLatestBuildForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])
        
    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)
        
    def test_getProjectTestPlans_unknownID(self):
        response = self.client.getProjectTestPlans(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])
        
    def test_getTestCase_unknownID(self):
        response = self.client.getTestCase(4711)
        # FAILURE in 1.9.3 API message: replacement does not work
        # The Test Case ID (testcaseid: %s) provided does not exist!
        #self.assertIn('4711', response[0]['message'])
        self.assertEqual(5000, response[0]['code'])
        
    def test_getTestCaseAttachments_unknownID(self):
        response = self.client.getTestCaseAttachments(4711)
        # FAILURE in 1.9.3 API message: replacement does not work
        # The Test Case ID (testcaseid: %s) provided does not exist!
        #self.assertIn('4711', response[0]['message'])
        self.assertEqual(5000, response[0]['code'])
        
    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        response = self.client.getTestCaseCustomFieldDesignValue(
                   4712, 1, 4711, 'a_field', 'a_detail')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])
        
    def test_getTestCaseIDByName_unknownID(self):
        response = self.client.getTestCaseIDByName('Big Bird')
        self.assertIn('getTestCaseIDByName', response[0]['message'])
        self.assertEqual(5030, response[0]['code'])

    def test_getTestCasesForTestPlan_unknownID(self):
        response = self.client.getTestCasesForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getTestCasesForTestSuite_unknownID(self):
        response = self.client.getTestCasesForTestSuite(4711, 2, 'a_detail')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(8000, response[0]['code'])

    def test_getTestPlanByName_unknownID(self):
        response = self.client.getTestPlanByName('project 4711', 'plan 4712')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7011, response[0]['code'])

    def test_getTestPlanPlatforms_unknownID(self):
        response = self.client.getTestPlanPlatforms(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getTestProjectByName_unknownID(self):
        response = self.client.getTestProjectByName('project 4711')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7011, response[0]['code'])

    def test_getTestSuiteByID_unknownID(self):
        response = self.client.getTestSuiteByID(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(8000, response[0]['code'])

    def test_getTestSuitesForTestPlan_unknownID(self):
        response = self.client.getTestSuitesForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getTestSuitesForTestSuite_unknownID(self):
        response = self.client.getTestSuitesForTestSuite(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(8000, response[0]['code'])

    def test_getTotalsForTestPlan_unknownID(self):
        response = self.client.getTotalsForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_createTestProject_unknownID(self):
        response = self.client.createTestProject('', 'P4711')
        self.assertIn('Empty name', response[0]['message'])
        self.assertEqual(7001, response[0]['code'])

    def test_createBuild_unknownID(self):
        response = self.client.createBuild(4711, 'Build 4712', 'note 4713')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_createTestPlan_unknownID(self):
        response = self.client.createTestPlan('plan 4711', 'project 4712')
        self.assertIn('4712', response[0]['message'])
        self.assertEqual(7011, response[0]['code'])

    def test_createTestSuite_unknownID(self):
        response = self.client.createTestSuite( 4711, 'suite 4712', 'detail 4713')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_createTestCase_unknownID(self):
        response = self.client.createTestCase('case 4711', 4712, 4713, 
                                               'Big Bird', 'summary 4714')
        self.assertIn('4713', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_reportTCResult_unknownID(self):
        response = self.client.reportTCResult(4711, 4712, 'build 4713', 'p', 
                                              'note 4714')
        # FAILURE in 1.9.3 API message: replacement does not work
        # The Test Case ID (testcaseid: %s) provided does not exist!
        #self.assertIn('4711', response[0]['message'])
        self.assertEqual(5000, response[0]['code'])

#    def test_uploadExecutionAttachment_unknownID(self):
#        response = self.client.uploadExecutionAttachment('file 4711', 4712, 
#                        'title 4713', 'descr. 4714')
#        self.assertIn('4711', response[0]['message'])

    def test_getProjectIDByName_unknownID(self):
        response = self.client.getProjectIDByName('project 4711')
        self.assertEqual(-1, response)
class TestLinkAPIGenericOfflineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIGeneric - does not interacts with a TestLink Server.
    works with DummyAPIGeneric which returns special test data
    """

    def setUp(self):
        self.api = TestLinkHelper().connect(DummyAPIGeneric)
        self.callArgs = None
        
#    def tearDown(self):
#        pass


    def test_convertPositionalArgs(self):
        response = self.api._convertPostionalArgs('DummyMethod',  [1,2,3])
        self.assertEqual({'Uno' : 1, 'due' :2, 'tre' : 3}, response)
        
    def test__convertPositionalArgs_missingConf(self):
        client = self.api
        def a_func(a_api): a_api._convertPostionalArgs('NoConfigMethod',  [1,2])
        self.assertRaises(TLArgError, a_func, client)
        
    def test__convertPositionalArgs_lessValues(self):
        client = self.api
        def a_func(a_api): a_api._convertPostionalArgs('DummyMethod',  [1,2])
        self.assertRaises(TLArgError, a_func, client)
        
    def test__convertPositionalArgs_moreValues(self):
        client = self.api
        def a_func(a_api): a_api._convertPostionalArgs('DummyMethod',  [1,2,3,4])
        self.assertRaises(TLArgError, a_func, client)

    def test_callServerWithPosArgs_pos(self):
        self.api.callServerWithPosArgs('DummyMethod',  1,2,3)
        self.assertEqual({'Uno' : 1, 'due' :2, 'tre' : 3}, self.api.callArgs)

    def test_callServerWithPosArgs_pos_opt(self):
        self.api.callServerWithPosArgs('DummyMethod',  1,2,3, quad=4)
        self.assertEqual({'Uno' : 1, 'due' :2, 'tre' : 3, 'quad' : 4}, self.api.callArgs)

    def test_callServerWithPosArgs_opt(self):
        self.api.callServerWithPosArgs('DummyMethod',  quad=4)
        self.assertEqual({'quad' : 4}, self.api.callArgs)

    def test_callServerWithPosArgs_none(self):
        self.api.callServerWithPosArgs('DummyMethod')
        self.assertEqual({}, self.api.callArgs)
        
    def test_checkResponse_emptyResponse(self):
        client = self.api
        def a_func(a_api, response): 
            a_api._checkResponse(response, 'DummyMethod',  
                                 {'Uno' : 1, 'due' :2, 'tre' : 3})
        self.assertRaises(TLResponseError, a_func, client, '')
        self.assertRaises(TLResponseError, a_func, client, [])
        
    def test_checkResponse_errorResponse(self):
        client = self.api
        responseA = [{'message': '(reportTCResult) - TC ID 709 does not exist!', 
                      'code': 5000}]
        def a_func(a_api, response): 
            a_api._checkResponse(response, 'DummyMethod',  
                                 {'Uno' : 1, 'due' :2, 'tre' : 3})
        self.assertRaises(TLResponseError, a_func, client, responseA)

    def test_checkResponse_okResponse(self):
        self.api._checkResponse(
                        [{'message': 'all fine, cause no key with name code'}],
                         'DummyMethod', {'Uno' : 1, 'due' :2, 'tre' : 3})
        self.api._checkResponse(
                        'some API Call juts returns one string without codes',
                         'DummyMethod', {'Uno' : 1, 'due' :2, 'tre' : 3})
        
    def test_checkResponse_booleanResponse(self):
        response = True
        self.api._checkResponse(response, 'DummyMethod', 
                                {'Uno' : 1, 'due' :2, 'tre' : 3})
        
    def test_checkResponse_dictionaryResponse(self):
        response = {'note' : 'uploadAttachment Calls return {..} and not [{..}]'}
        self.api._checkResponse(response, 'DummyMethod', 
                                {'Uno' : 1, 'due' :2, 'tre' : 3})
        
    def test_checkResponse_errorResponse_sringCode(self):
        client = self.api
        
        responseA = [{'message': '(getUserByID) - Cannot Find User with DB ID (4711).', 
                      'code': 'NO_USER_BY_ID_LOGIN'}]
        def a_func(a_api, response): 
            a_api._checkResponse(response, 'getUserByID',  
                                 {'userid' : 4711})
        self.assertRaises(TLResponseError, a_func, client, responseA)

    def test__apiMethodArgNames_noArgs(self):
        response = self.api._apiMethodArgNames('sayHello')
        self.assertEqual(response, ([], [], []))

    def test_whatArgs_noArgs(self):
        response = self.api.whatArgs('sayHello')
        self.assertRegex(response, 'sayHello().*')
        
    def test__apiMethodArgNames_onlyOptionalArgs(self):
        response = self.api._apiMethodArgNames('getTestCaseAttachments')
        self.assertEqual(response[0], [])
        self.assertGreater(len(response[1]), 0)
        self.assertEqual(response[2], [])

    def test_whatArgs_onlyOptionalArgs(self):
        response = self.api.whatArgs('getTestCaseAttachments')
        self.assertRegex(response, 'getTestCaseAttachments\(\[.*=<.*>\].*\).*')
        
    def test__apiMethodArgNames__OptionalAndPositionalArgs(self):
        response = self.api._apiMethodArgNames('createBuild')
        self.assertGreater(len(response[0]), 0)
        self.assertGreater(len(response[1]), 0)
        self.assertEqual(response[2], [])

    def test_whatArgs_OptionalAndPositionalArgs(self):
        response = self.api.whatArgs('createBuild')
        self.assertRegex(response, 'createBuild\(<.*>.*\).*')

    def test__apiMethodArgNames__MandatoryArgs(self):
        response = self.api._apiMethodArgNames('uploadExecutionAttachment')
        self.assertGreater(len(response[0]), 0)
        self.assertGreater(len(response[1]), 0)
        self.assertGreater(len(response[2]), 0)

    def test_whatArgs_MandatoryArgs(self):
        response = self.api.whatArgs('uploadExecutionAttachment')
        self.assertRegex(response, 
                    'uploadExecutionAttachment\(<attachmentfile>, <.*>.*\).*')

    def test_whatArgs_unknownMethods(self):
        response = self.api.whatArgs('apiUnknown')
        self.assertRegex(response, 
                "callServerWithPosArgs\('apiUnknown', \[apiArg=<apiArg>\]\)")
        
    def test_noWrapperName_apiMethods(self):
        " decorator test: API Methods internal function name should be unchanged "
        
        # apiMethod with decorator @decoApiCallWithoutArgs
        self.assertEqual('sayHello', self.api.sayHello.__name__)
        # apiMethod with decorator @decoApiCallWithArgs
        self.assertEqual('repeat', self.api.repeat.__name__)
        # apiMethod with decorator @decoApiCallAddDevKey 
        self.assertEqual('createBuild', self.api.createBuild.__name__)
        # apiMethod with decorator @decoMakerApiCallReplaceTLResponseError()
        self.assertEqual('getProjectTestPlans', self.api.getProjectTestPlans.__name__)
        # apiMethod with decorator @decoApiCallAddAttachment
        self.assertEqual('uploadExecutionAttachment', self.api.uploadExecutionAttachment.__name__)
        
    def test_ping(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.ping()
        self.assertEqual('Hey Folks!', response)
        
        
    def test_getProjectTestPlans_noPlan(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectTestPlans('noPlan')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getProjectTestPlans_onePlan(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectTestPlans('onePlan')
        self.assertEqual('21', response[0]['testproject_id'])
        self.assertEqual(1, len(response))
        
    def test_getProjectPlatforms_noPlatform(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectPlatforms('noPlatform')
        self.assertEqual({}, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getProjectPlatforms_twoPlatforms(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectPlatforms('twoPlatforms')
        self.assertEqual('1', response['dutch']['id'])
        self.assertEqual(2, len(response))
        
        
    def test_getBuildsForTestPlan_noBuild(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getBuildsForTestPlan('noBuild')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestPlanPlatforms_noPlatform(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestPlanPlatforms('noPlatform')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestPlanPlatforms_twoPlatforms(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestPlanPlatforms('twoPlatforms')
        self.assertEqual('dutch', response[0]['name'])
        self.assertEqual(2, len(response))

    def test_getTestSuitesForTestPlan_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestSuitesForTestPlan('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
       
    def test_getTestSuitesForTestSuite_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestSuitesForTestSuite('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getFirstLevelTestSuitesForTestProject_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getFirstLevelTestSuitesForTestProject('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestCasesForTestSuite_noTestCase(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCasesForTestSuite('noTestCase')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCasesForTestSuite_keyWords(self):
        self.api.loadScenario(SCENARIO_KEYWORDS)
        response = self.api.getTestCasesForTestSuite('keyWords', details='full', 
                                                     getkeywords=True)
        self.assertIn('keywords', response[0])
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
           
    def test_whatArgs_getTestCasesForTestSuite(self):
        argsDescription = self.api.whatArgs('getTestCasesForTestSuite')
        self.assertIn('getkeywords=<getkeywords>', argsDescription)

    def test_getTestCasesForTestPlan_noTestCase(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCasesForTestPlan('noTestCase')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestCaseIDByName_dictResult(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCaseIDByName('dictResult', 
                                            testprojectname='NEW_PROJECT_API')
        self.assertEqual(dict, type(response))
        self.assertEqual('TESTCASE_B', response['1']['name']) 
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestCaseIDByName_listResult(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCaseIDByName('listResult')
        self.assertEqual(list, type(response))
        self.assertEqual('TESTCASE_AA', response[0]['name']) 
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_testLinkVersion_beforeTL199(self):
        self.api.loadScenario(SCENARIO_TL198)
        response = self.api.testLinkVersion()
        self.assertEqual('<= 1.9.8', response)
        
    def test_testLinkVersion_withTL199(self):
        self.api.loadScenario(SCENARIO_TL199)
        response = self.api.testLinkVersion()
        self.assertEqual('1.9.9', response)
        
    def test_connectionInfo_beforeTL199(self):
        self.api.loadScenario(SCENARIO_TL198)
        response = self.api.connectionInfo()
        self.assertRegex(response, '\d*\.\d*\.\d*')
        
    def test_getTestCaseCustomFieldDesignValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        with self.assertRaisesRegex(TLResponseError, '9003.*Custom Field.*not assigned'):
            response = self.api.getTestCaseCustomFieldDesignValue('GPROAPI8-2', 
                            1, '7760', 'cf_notAssigned', details='full')
            
    def test_getTestCaseCustomFieldDesignValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldDesignValue('GPROAPI8-2', 
                            1, '7760', 'cf_full', details='full') 
        self.assertEqual('a custom spec design string', response['value'])           
        self.assertEqual('1', response['enable_on_design'])           
        self.assertEqual('0', response['enable_on_testplan_design']) 
        self.assertEqual('0', response['enable_on_execution'])           

    def test_getTestCaseCustomFieldDesignValue_value(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldDesignValue('GPROAPI8-2', 
                            1, '7760', 'cf_value', details='value') 
        self.assertEqual('a custom spec design string', response)           

    def test_getTestCaseCustomFieldDesignValue_valueEmpty(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldDesignValue('GPROAPI8-2', 
                            1, '7760', 'cf_valueEmpty', details='value') 
        self.assertEqual('', response)   
                
    def test_getTestCaseCustomFieldDesignValue_simple(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldDesignValue('GPROAPI8-2', 
                            1, '7760', 'cf_simple', details='simple') 
        self.assertEqual('a custom spec design string', response['value'])           

    def test_updateTestCaseCustomFieldDesignValue_simple(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.updateTestCaseCustomFieldDesignValue('GPROAPI8-2', 
                            1, '7760', {'cf_field1'  : 'a_string'}) 
        self.assertEqual('', response)

    def test_getTestCaseCustomFieldExecutionValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldExecutionValue(
                                    'cf_notAssigned', '7760', 1, '792', '7761') 
        self.assertEqual(None, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCaseCustomFieldExecutionValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldExecutionValue(
                                        'cf_full', '7760', 1, '792', '7761') 
        self.assertEqual('a custom exec string', response['value'])           
        self.assertEqual('0', response['enable_on_design']) 
        self.assertEqual('0', response['enable_on_testplan_design']) 
        self.assertEqual('1', response['enable_on_execution'])           

    def test_getTestCaseCustomFieldTestPlanDesignValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldTestPlanDesignValue(
                                    'cf_notAssigned', '7760', 1, '7761', '779') 
        self.assertEqual(None, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCaseCustomFieldTestPlanDesignValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestCaseCustomFieldTestPlanDesignValue(
                                        'cf_full', '7760', 1, '7761', '779') 
        self.assertEqual('a custom PlanDesign string', response['value'])           
        self.assertEqual('0', response['enable_on_design']) 
        self.assertEqual('1', response['enable_on_testplan_design']) 
        self.assertEqual('0', response['enable_on_execution'])           

    def test_getTestSuiteCustomFieldDesignValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestSuiteCustomFieldDesignValue(
                                            'cf_notAssigned', '7760', '7762') 
        self.assertEqual(None, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestSuiteCustomFieldDesignValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestSuiteCustomFieldDesignValue(
                                                    'cf_full', '7760', '7762') 
        self.assertEqual('a custom TSuite string', response['value'])           
        self.assertEqual('1', response['enable_on_design']) 
        self.assertEqual('0', response['enable_on_testplan_design']) 
        self.assertEqual('0', response['enable_on_execution'])           

    def test_getTestPlanCustomFieldDesignValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestPlanCustomFieldDesignValue(
                                            'cf_notAssigned', '7760', '7761') 
        self.assertEqual(None, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestPlanCustomFieldDesignValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getTestPlanCustomFieldDesignValue(
                                                    'cf_full', '7760', '7761') 
        self.assertEqual('a custom TPlan string', response['value'])           
        self.assertEqual('1', response['enable_on_design']) 
        self.assertEqual('0', response['enable_on_testplan_design']) 
        self.assertEqual('0', response['enable_on_execution'])           

    def test_getReqSpecCustomFieldDesignValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getReqSpecCustomFieldDesignValue(
                                            'cf_notAssigned', '7760', '7789') 
        self.assertEqual(None, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getReqSpecCustomFieldDesignValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getReqSpecCustomFieldDesignValue(
                                                    'cf_full', '7760', '7789') 
        self.assertEqual('a custom ReqSpec string', response['value'])           
        self.assertEqual('1', response['enable_on_design']) 
        self.assertEqual('0', response['enable_on_testplan_design']) 
        self.assertEqual('0', response['enable_on_execution'])           

    def test_getRequirementCustomFieldDesignValue_notAssigned(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getRequirementCustomFieldDesignValue(
                                            'cf_notAssigned', '7760', '7791') 
        self.assertEqual(None, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getRequirementCustomFieldDesignValue_full(self):
        self.api.loadScenario(SCENARIO_CUSTOM_FIELDS)
        response = self.api.getRequirementCustomFieldDesignValue(
                                                    'cf_full', '7760', '7791') 
        self.assertEqual('a custom Req string', response['value'])           
        self.assertEqual('1', response['enable_on_design']) 
        self.assertEqual('0', response['enable_on_testplan_design']) 
        self.assertEqual('0', response['enable_on_execution'])   
        
    def test_reportTCResult_user(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.reportTCResult(4712, 'p', testcaseid=4711, 
                                    buildname='build 4713', notes='note 4714',
                                    user='******') 
        self.assertEqual('reportTCResult', response[0]['operation']) 
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        self.assertEqual('a login name', self.api.callArgs['user'])
        
    def test_whatArgs_reportTCResult(self):
        argsDescription = self.api.whatArgs('reportTCResult')
        self.assertIn('user=<user>', argsDescription)
        
    def test_whatArgs_getLastExecutionResult(self):
        argsDescription = self.api.whatArgs('getLastExecutionResult')
        self.assertIn('options=<options>', argsDescription)
        self.assertIn('getBugs', argsDescription)

    def test__getAttachmentArgs_textfile(self):
        "py3 issue #39 TypeError: expected bytes-like object, not str"
        NEWATTACHMENT_PY= os.path.realpath(__file__)
        # under py2, on windows text files should be open with 'r' mode and 
        # binary files with 'rb' 
        # see http://docs.python.org/2/tutorial/inputoutput.html#reading-and-writing-files
        # under py3, text files open with 'r' on windows makes problem
        # see https://github.com/lczub/TestLink-API-Python-client/issues/39
        a_file = open(NEWATTACHMENT_PY, BINARY_READ_MODE)
        args = self.api._getAttachmentArgs(a_file)
        self.assertEqual('testlinkapigeneric_offline_test.py', args['filename'])
        if sys.version_info[0] == 2 and sys.version_info[1] == 6:
            self.assertEqual('text/x-python', args['filetype'])
        else:
            self.assertEqual('text/plain', args['filetype'])

        self.assertIsNotNone(args['content'])
class TestLinkAPIOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """
    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIGeneric)

#    def tearDown(self):
#        pass

    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)

    def test_checkDevKey_unknownKey(self):
        with self.assertRaisesRegexp(TLResponseError, '2000.*invalid'):
            self.client.checkDevKey(devKey='unknownKey')

    def test_sayHello(self):
        response = self.client.sayHello()
        self.assertEqual('Hello!', response)

    def test_repeat(self):
        response = self.client.repeat('Yellow Submarine')
        self.assertEqual('You said: Yellow Submarine', response)

    def test_about(self):
        response = self.client.about()
        self.assertIn('Testlink API', response)

    def test_doesUserExist_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '10000.*Big Bird'):
            self.client.doesUserExist('Big Bird')

    def test_createTestProject_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7001.*Empty name'):
            self.client.createTestProject(testprojectname='',
                                          testcaseprefix='P4711')

    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)

    def test_createTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4712'):
            self.client.createTestPlan('plan 4711', 'project 4712')

    def test_createTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.createTestSuite(4711, 'suite 4712', 'detail 4713')

    def test_createTestCase_unknownID(self):
        tc_steps = []
        with self.assertRaisesRegexp(TLResponseError, '7000.*4713'):
            self.client.createTestCase('case 4711', 4712, 4713, 'Big Bird',
                                       'summary 4714', tc_steps)

    def test_getBuildsForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getBuildsForTestPlan(4711)

    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getFirstLevelTestSuitesForTestProject(4711)

    def test_getFullPath_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, 'getFullPath.*234'):
            self.client.getFullPath('4711')

    def test_getLastExecutionResult_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getLastExecutionResult(4711, testcaseid=4712)

    def test_getLatestBuildForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getLatestBuildForTestPlan(4711)

    def test_getProjectTestPlans_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getProjectTestPlans(4711)

    def test_getProjectPlatforms_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getProjectPlatforms(4711)

    def test_getTestCase_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.getTestCase(testcaseid=4711)

    def test_getTestCase_unknownExternalID(self):
        with self.assertRaisesRegexp(TLResponseError, '5040.*GPROAPI-4711'):
            self.client.getTestCase(testcaseexternalid='GPROAPI-4711')

    def test_getTestCaseAttachments_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.getTestCaseAttachments(testcaseid=4711)

    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getTestCaseCustomFieldDesignValue('TC-4712',
                                                          1,
                                                          4711,
                                                          'a_field',
                                                          details='a_detail')

    def test_getTestCaseIDByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5030.*Cannot find'):
            self.client.getTestCaseIDByName('Big Bird')

    def test_getTestCasesForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestCasesForTestPlan(4711)

    def test_getTestCasesForTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestCasesForTestSuite(4711)

    def test_getTestPlanByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.getTestPlanByName('project 4711', 'plan 4712')

    def test_getTestPlanPlatforms_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestPlanPlatforms(4711)

    def test_getTestProjectByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.getTestProjectByName('project 4711')

    def test_getTestSuiteByID_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestSuiteByID(4711)

    def test_getTestSuitesForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestSuitesForTestPlan(4711)

    def test_getTestSuitesForTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestSuitesForTestSuite(4711)

    def test_getTotalsForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTotalsForTestPlan(4711)

    def test_createBuild_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.createBuild(4711, 'Build 4712', buildnotes='note 4713')

    def test_reportTCResult_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.reportTCResult(4712,
                                       'p',
                                       testcaseid=4711,
                                       buildname='build 4713',
                                       notes='note 4714')

    def test_uploadExecutionAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadExecutionAttachment(attachemantFile,
                                                  4712,
                                                  title='title 4713',
                                                  description='descr. 4714')

    def test_createPlatform_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.createPlatform('Project 4711',
                                       'Platform 4712',
                                       notes='note 4713')

    def test_addPlatformToTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.addPlatformToTestPlan(4711, 'Platform 4712')

    def test_removePlatformFromTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.removePlatformFromTestPlan(4711, 'Platform 4712')

    def test_addTestCaseToTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.addTestCaseToTestPlan(4711, 4712, 'N-4713', 1)

    def test_updateTestCase_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-4711'):
            self.client.updateTestCase('N-4711', version=1)

    def test_createTestCaseSteps_unknownID(self):
        steps = [{
            'actions': "Step action 6 -b added by updateTestCase",
            'expected_results': "Step result 6 - b added",
            'step_number': 6,
            'execution_type': 1
        }]
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-4711'):
            self.client.createTestCaseSteps('update',
                                            steps,
                                            testcaseexternalid='N-4711',
                                            version=1)

    def test_deleteTestCaseSteps_unknownID(self):
        steps = [2, 8]
        with self.assertRaisesRegexp(TLResponseError, '5040.*N-4711'):
            self.client.deleteTestCaseSteps('N-4711', steps, version=1)

    def test_uploadRequirementSpecificationAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadRequirementSpecificationAttachment(
                attachemantFile,
                4712,
                title='title 4713',
                description='descr. 4714')

    def test_uploadRequirementAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadRequirementAttachment(attachemantFile,
                                                    4712,
                                                    title='title 4713',
                                                    description='descr. 4714')

    def test_uploadTestProjectAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '7000.*4712'):
            self.client.uploadTestProjectAttachment(attachemantFile,
                                                    4712,
                                                    title='title 4713',
                                                    description='descr. 4714')

    def test_uploadTestSuiteAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '8000.*4712'):
            self.client.uploadTestSuiteAttachment(attachemantFile,
                                                  4712,
                                                  title='title 4713',
                                                  description='descr. 4714')

    def test_uploadTestCaseAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '5000.*testcaseid'):
            self.client.uploadTestCaseAttachment(attachemantFile,
                                                 4712,
                                                 title='title 4713',
                                                 description='descr. 4714')

    def test_uploadAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadAttachment(attachemantFile,
                                         4712,
                                         'nodes_hierarchy',
                                         title='title 4713',
                                         description='descr. 4714')

    def test_checkDevKey_unknownKey(self):
        with self.assertRaisesRegexp(TLResponseError, '2000.*invalid'):
            self.client.checkDevKey(devKey='unknownKey')

    def test_testLinkVersion(self):
        response = self.client.testLinkVersion()
        self.assertRegexpMatches(response, '\d*\.\d*\.\d*')

    def test_getUserByLogin_unknownKey(self):
        with self.assertRaisesRegexp(TLResponseError, '10000.*User Login'):
            self.client.getUserByLogin('unknownUser')

    def test_getUserByID_unknownKey(self):
        with self.assertRaisesRegexp(TLResponseError,
                                     'NO_USER_BY_ID_LOGIN.*User with DB ID'):
            self.client.getUserByID(4711)


#     def test_setTestMode(self):
#         response = self.client.setTestMode(True)
#         self.assertTrue(response)
#         response = self.client.setTestMode(False)
#         self.assertTrue(response)

    def test_deleteExecution_unknownKey(self):
        try:
            response = self.client.deleteExecution(4711)
            # case: TL configuration allows deletion of executions
            # response returns Success, even if executionID is unkown
            self.assertEqual([{
                'status': True,
                'message': 'Success!',
                'id': 4711,
                'operation': 'deleteExecution'
            }], response)
        except TLResponseError as tl_err:
            # case: TL configuration does not allow deletion of executions
            # Expects: 232: Configuration does not allow delete executions
            self.assertEqual(232, tl_err.code)

    def test_setTestCaseExecutionType_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4712'):
            self.client.setTestCaseExecutionType('N-4711', 1, 4712, 1)

    def test_assignRequirements_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4712'):
            self.client.assignRequirements('N-4711', 4712,
                                           [{
                                               'req_spec': 4713,
                                               'requirements': [4714, 4717]
                                           }, {
                                               'req_spec': 4723,
                                               'requirements': [4725]
                                           }])
class TestLinkAPIOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """

    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIClient)

    #    def tearDown(self):
    #        pass

    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)

    def test_about(self):
        response = self.client.about()
        self.assertIn("Testlink API", response)

    def test_ping(self):
        response = self.client.ping()
        self.assertEqual("Hello!", response)

    def test_echo(self):
        response = self.client.echo("Yellow Submarine")
        self.assertEqual("You said: Yellow Submarine", response)

    def test_doesUserExist_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "10000.*Big Bird"):
            self.client.doesUserExist("Big Bird")

    def test_getBuildsForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getBuildsForTestPlan(40000711)

    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getFirstLevelTestSuitesForTestProject(40000711)

    def test_getFullPath_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "getFullPath.*234"):
            self.client.getFullPath("40000711")

    def test_getLastExecutionResult_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getLastExecutionResult(40000711, 40000712)

    def test_getLatestBuildForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getLatestBuildForTestPlan(40000711)

    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)

    def test_getProjectTestPlans_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getProjectTestPlans(40000711)

    def test_getProjectPlatforms_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getProjectPlatforms(40000711)

    def test_getTestCase_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5000.*40000711"):
            self.client.getTestCase(40000711)

    def test_getTestCase_unknownExternalID(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*N-2"):
            self.client.getTestCase(testcaseexternalid="N-2")

    def test_getTestCaseAttachments_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5000.*40000711"):
            self.client.getTestCaseAttachments(40000711)

    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getTestCaseCustomFieldDesignValue("TC-40000712", 1, 40000711, "a_field", "a_detail")

    def test_getTestCaseIDByName_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5030.*Cannot find"):
            self.client.getTestCaseIDByName("Big Bird")

    def test_getTestCasesForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getTestCasesForTestPlan(40000711)

    def test_getTestCasesForTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "8000.*40000711"):
            self.client.getTestCasesForTestSuite(40000711, 2, "a_detail")

    def test_getTestPlanByName_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7011.*40000711"):
            self.client.getTestPlanByName("project 40000711", "plan 40000712")

    def test_getTestPlanPlatforms_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getTestPlanPlatforms(40000711)

    def test_getTestProjectByName_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7011.*40000711"):
            self.client.getTestProjectByName("project 40000711")

    def test_getTestSuiteByID_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "8000.*40000711"):
            self.client.getTestSuiteByID(40000711)

    def test_getTestSuitesForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getTestSuitesForTestPlan(40000711)

    def test_getTestSuitesForTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "8000.*40000711"):
            self.client.getTestSuitesForTestSuite(40000711)

    def test_getTotalsForTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getTotalsForTestPlan(40000711)

    def test_createTestProject_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7001.*Empty name"):
            self.client.createTestProject("", "P40000711")

    def test_createBuild_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.createBuild(40000711, "Build 40000712", "note 40000713")

    def test_createTestPlan_projectname_posArg_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7011.*40000712"):
            self.client.createTestPlan("plan 40000711", "project 40000712")

    def test_createTestSuite_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.createTestSuite(40000711, "suite 40000712", "detail 40000713")

    def test_createTestCase_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000713"):
            self.client.createTestCase("case 40000711", 40000712, 40000713, "Big Bird", "summary 40000714")

    def test_reportTCResult_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5000.*40000711"):
            self.client.reportTCResult(40000711, 40000712, "build 40000713", "p", "note 40000714")

    def test_uploadExecutionAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), "r")
        with self.assertRaisesRegex(TLResponseError, "6004.*40000712"):
            self.client.uploadExecutionAttachment(attachemantFile, 40000712, "title 40000713", "descr. 40000714")

    def test_getProjectIDByName_unknownID(self):
        response = self.client.getProjectIDByName("project 40000711")
        self.assertEqual(-1, response)

    def test_createPlatform_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7011.*40000711"):
            self.client.createPlatform("Project 40000711", "Platform 40000712", notes="note 40000713")

    def test_addTestCaseToTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.addTestCaseToTestPlan(40000711, 40000712, "N-40000713", 1)

    def test_updateTestCase_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*N-40000711"):
            self.client.updateTestCase("N-40000711", version=1)

    def test_createTestCaseSteps_unknownID(self):
        steps = [
            {
                "actions": "Step action 6 -b added by updateTestCase",
                "expected_results": "Step result 6 - b added",
                "step_number": 6,
                "execution_type": 1,
            }
        ]
        with self.assertRaisesRegex(TLResponseError, "5040.*N-40000711"):
            self.client.createTestCaseSteps("update", steps, testcaseexternalid="N-40000711", version=1)

    def test_deleteTestCaseSteps_unknownID(self):
        steps = [2, 8]
        with self.assertRaisesRegex(TLResponseError, "5040.*N-40000711"):
            self.client.deleteTestCaseSteps("N-40000711", steps, version=1)

    def test_uploadRequirementSpecificationAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, "r")
        with self.assertRaisesRegex(TLResponseError, "6004.*40000712"):
            self.client.uploadRequirementSpecificationAttachment(
                attachemantFile, 40000712, title="title 40000713", description="descr. 40000714"
            )

    def test_uploadRequirementAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, "r")
        with self.assertRaisesRegex(TLResponseError, "6004.*40000712"):
            self.client.uploadRequirementAttachment(
                attachemantFile, 40000712, title="title 40000713", description="descr. 40000714"
            )

    def test_uploadTestProjectAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, "r")
        with self.assertRaisesRegex(TLResponseError, "7000.*40000712"):
            self.client.uploadTestProjectAttachment(
                attachemantFile, 40000712, title="title 40000713", description="descr. 40000714"
            )

    def test_uploadTestSuiteAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, "r")
        with self.assertRaisesRegex(TLResponseError, "8000.*40000712"):
            self.client.uploadTestSuiteAttachment(
                attachemantFile, 40000712, title="title 40000713", description="descr. 40000714"
            )

    def test_uploadTestCaseAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, "r")
        with self.assertRaisesRegex(TLResponseError, "5000.*testcaseid"):
            self.client.uploadTestCaseAttachment(
                attachemantFile, 40000712, title="title 40000713", description="descr. 40000714"
            )

    def test_uploadAttachment_unknownID(self):
        attachemantFile = open(ATTACHMENT_EXAMPLE_TEXT, "r")
        with self.assertRaisesRegex(TLResponseError, "6004.*Invalid Foreign Key ID"):
            self.client.uploadAttachment(
                attachemantFile, "0000", "nodes_hierarchy", title="title 40000713", description="descr. 40000714"
            )

    def test_testLinkVersion(self):
        response = self.client.testLinkVersion()
        self.assertRegex(response, "\d*\.\d*\.\d*")

    def test_getUserByLogin_unknownKey(self):
        with self.assertRaisesRegex(TLResponseError, "10000.*User Login"):
            self.client.getUserByLogin(user="******")

    #     def test_setTestMode(self):
    #         response = self.client.setTestMode(True)
    #         self.assertTrue(response)
    #         response = self.client.setTestMode(False)
    #         self.assertTrue(response)

    def test_deleteExecution_unknownKey(self):
        try:
            response = self.client.deleteExecution(40000711)
            # case: TL configuration allows deletion of executions
            # response returns Success, even if executionID is unkown
            self.assertEqual(
                [{"status": True, "message": "Success!", "id": 40000711, "operation": "deleteExecution"}], response
            )
        except TLResponseError as tl_err:
            # case: TL configuration does not allow deletion of executions
            # Expects: 232: Configuration does not allow delete executions
            self.assertEqual(232, tl_err.code)

    def test_setTestCaseExecutionType_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000712"):
            self.client.setTestCaseExecutionType("N-40000711", 1, 40000712, 1)

    def test_assignRequirements_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000712"):
            self.client.assignRequirements(
                "N-40000711",
                40000712,
                [
                    {"req_spec": 40000713, "requirements": [40000714, 40000717]},
                    {"req_spec": 4723, "requirements": [4725]},
                ],
            )

    def test_getExecCountersByBuild_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getExecCountersByBuild(40000711)

    def test_getTestCaseCustomFieldExecutionValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "236.*version/executionid"):
            self.client.getTestCaseCustomFieldExecutionValue("cf_full", "40000711", 1, "715", "40000713")

    def test_getTestCaseCustomFieldTestPlanDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getTestCaseCustomFieldTestPlanDesignValue("cf_full", "40000711", 1, "40000713", "615")

    def test_updateTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.updateTestCaseCustomFieldDesignValue(
                "TC-40000712", 1, 40000711, {"cf_field1": "value1", "cf_field2": "value2"}
            )

    def test_getTestSuiteCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getTestSuiteCustomFieldDesignValue("cf_full", 40000711, 40000713)

    def test_getTestPlanCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getTestPlanCustomFieldDesignValue("cf_full", 40000711, 40000712)

    def test_getReqSpecCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getReqSpecCustomFieldDesignValue("cf_full", 40000711, 4732)

    def test_getRequirementCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getRequirementCustomFieldDesignValue("cf_full", 40000711, 4734)

    def test_assignTestCaseExecutionTask_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.assignTestCaseExecutionTask(
                "username", 40000711, "TC-40000712", buildname="build 40000713", platformname="platform 40000714"
            )

    def test_getTestCaseBugs_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getTestCaseBugs(
                40000711, testcaseexternalid="TC-40000712", buildname="build 40000713", platformname="platform 40000714"
            )

    def test_getTestCaseAssignedTester_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.getTestCaseAssignedTester(
                40000711, "TC-40000712", buildname="build 40000713", platformname="platform 40000714"
            )

    def test_unassignTestCaseExecutionTask_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.unassignTestCaseExecutionTask(
                40000711,
                "TC-40000712",
                buildname="build 40000713",
                platformname="platform 40000714",
                user="******",
                action="unassignOne",
            )

    def test_getProjectKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000711"):
            self.client.getProjectKeywords(40000711)

    def test_getTestCaseKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*40000712"):
            self.client.getTestCaseKeywords(testcaseid=40000712)

    def test_getTestCaseKeywords_unknownID_set(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*40000712"):
            self.client.getTestCaseKeywords(testcaseid=[40000712, 40000713])

    def test_getTestCaseKeywords_unknownID_external_single(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*TC-40000712"):
            self.client.getTestCaseKeywords(testcaseexternalid="TC-40000712")

    def test_getTestCaseKeywords_unknownID_external_set(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*TC-40000712"):
            self.client.getTestCaseKeywords(testcaseexternalid=["TC-40000712", "TC-40000713"])

    def test_deleteTestPlan_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "3000.*40000711"):
            self.client.deleteTestPlan(40000711)

    def test_addTestCaseKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*TC-40000712"):
            self.client.addTestCaseKeywords({"TC-40000712": ["KeyWord01", "KeyWord03"]})

    def test_removeTestCaseKeywords_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "5040.*TC-40000712"):
            self.client.removeTestCaseKeywords({"TC-40000712": ["KeyWord01"]})

    def test_deleteTestProject_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7013.*TProjectPrefix"):
            self.client.deleteTestProject("TProjectPrefix")

    def test_createTestPlan_projectname_optArg_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7011.*40000712"):
            self.client.createTestPlan("plan 40000711", testprojectname="project 40000712")

    def test_createTestPlan_prefix_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "NO.*TProjectPrefix"):
            self.client.createTestPlan("plan 40000713", prefix="TProjectPrefix")

    def test_updateTestSuiteCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegex(TLResponseError, "7000.*40000712"):
            self.client.updateTestSuiteCustomFieldDesignValue(
                "40000712 TP-ID", "40000711 TS-ID", {"cf_tc_ex_string": "a custom exec value", "cf_tc_ex_numeric": 111}
            )
예제 #8
0
class TestLinkAPIOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """
    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIClient)

#    def tearDown(self):
#        pass

    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)

    def test_about(self):
        response = self.client.about()
        self.assertIn('Testlink API', response)

    def test_ping(self):
        response = self.client.ping()
        self.assertEqual('Hello!', response)

    def test_echo(self):
        response = self.client.echo('Yellow Submarine')
        self.assertEqual('You said: Yellow Submarine', response)

    def test_doesUserExist_unknownID(self):
        response = self.client.doesUserExist('Big Bird')
        self.assertIn('Big Bird', response[0]['message'])
        self.assertEqual(10000, response[0]['code'])

    def test_getBuildsForTestPlan_unknownID(self):
        response = self.client.getBuildsForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        response = self.client.getFirstLevelTestSuitesForTestProject(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_getFullPath_unknownID(self):
        response = self.client.getFullPath(4711)
        self.assertIn('getFullPath', response[0]['message'])
        self.assertEqual(234, response[0]['code'])

    def test_getLastExecutionResult_unknownID(self):
        response = self.client.getLastExecutionResult(4711, 4712)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getLatestBuildForTestPlan_unknownID(self):
        response = self.client.getLatestBuildForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)

    def test_getProjectTestPlans_unknownID(self):
        response = self.client.getProjectTestPlans(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_getTestCase_unknownID(self):
        response = self.client.getTestCase(4711)
        # FAILURE in 1.9.3 API message: replacement does not work
        # The Test Case ID (testcaseid: %s) provided does not exist!
        #self.assertIn('4711', response[0]['message'])
        self.assertEqual(5000, response[0]['code'])

    def test_getTestCaseAttachments_unknownID(self):
        response = self.client.getTestCaseAttachments(4711)
        # FAILURE in 1.9.3 API message: replacement does not work
        # The Test Case ID (testcaseid: %s) provided does not exist!
        #self.assertIn('4711', response[0]['message'])
        self.assertEqual(5000, response[0]['code'])

    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        response = self.client.getTestCaseCustomFieldDesignValue(
            4712, 1, 4711, 'a_field', 'a_detail')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_getTestCaseIDByName_unknownID(self):
        response = self.client.getTestCaseIDByName('Big Bird')
        self.assertIn('getTestCaseIDByName', response[0]['message'])
        self.assertEqual(5030, response[0]['code'])

    def test_getTestCasesForTestPlan_unknownID(self):
        response = self.client.getTestCasesForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getTestCasesForTestSuite_unknownID(self):
        response = self.client.getTestCasesForTestSuite(4711, 2, 'a_detail')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(8000, response[0]['code'])

    def test_getTestPlanByName_unknownID(self):
        response = self.client.getTestPlanByName('project 4711', 'plan 4712')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7011, response[0]['code'])

    def test_getTestPlanPlatforms_unknownID(self):
        response = self.client.getTestPlanPlatforms(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getTestProjectByName_unknownID(self):
        response = self.client.getTestProjectByName('project 4711')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7011, response[0]['code'])

    def test_getTestSuiteByID_unknownID(self):
        response = self.client.getTestSuiteByID(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(8000, response[0]['code'])

    def test_getTestSuitesForTestPlan_unknownID(self):
        response = self.client.getTestSuitesForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_getTestSuitesForTestSuite_unknownID(self):
        response = self.client.getTestSuitesForTestSuite(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(8000, response[0]['code'])

    def test_getTotalsForTestPlan_unknownID(self):
        response = self.client.getTotalsForTestPlan(4711)
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_createTestProject_unknownID(self):
        response = self.client.createTestProject('', 'P4711')
        self.assertIn('Empty name', response[0]['message'])
        self.assertEqual(7001, response[0]['code'])

    def test_createBuild_unknownID(self):
        response = self.client.createBuild(4711, 'Build 4712', 'note 4713')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(3000, response[0]['code'])

    def test_createTestPlan_unknownID(self):
        response = self.client.createTestPlan('plan 4711', 'project 4712')
        self.assertIn('4712', response[0]['message'])
        self.assertEqual(7011, response[0]['code'])

    def test_createTestSuite_unknownID(self):
        response = self.client.createTestSuite(4711, 'suite 4712',
                                               'detail 4713')
        self.assertIn('4711', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_createTestCase_unknownID(self):
        response = self.client.createTestCase('case 4711', 4712, 4713,
                                              'Big Bird', 'summary 4714')
        self.assertIn('4713', response[0]['message'])
        self.assertEqual(7000, response[0]['code'])

    def test_reportTCResult_unknownID(self):
        response = self.client.reportTCResult(4711, 4712, 'build 4713', 'p',
                                              'note 4714')
        # FAILURE in 1.9.3 API message: replacement does not work
        # The Test Case ID (testcaseid: %s) provided does not exist!
        #self.assertIn('4711', response[0]['message'])
        self.assertEqual(5000, response[0]['code'])


#    def test_uploadExecutionAttachment_unknownID(self):
#        response = self.client.uploadExecutionAttachment('file 4711', 4712,
#                        'title 4713', 'descr. 4714')
#        self.assertIn('4711', response[0]['message'])

    def test_getProjectIDByName_unknownID(self):
        response = self.client.getProjectIDByName('project 4711')
        self.assertEqual(-1, response)
class TestLinkAPIOnlineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIClient - interacts with a TestLink Server.
    works with the example project NEW_PROJECT_API (see TestLinkExample.py)
    """

    def setUp(self):
        self.client = TestLinkHelper().connect(TestlinkAPIGeneric)

#    def tearDown(self):
#        pass

    def test_checkDevKey(self):
        response = self.client.checkDevKey()
        self.assertEqual(True, response)
        
    def test_checkDevKey_unknownKey(self):
        with self.assertRaisesRegexp(TLResponseError, '2000.*invalid'):
            self.client.checkDevKey(devKey='unknownKey')
        
    def test_sayHello(self):
        response = self.client.sayHello()
        self.assertEqual('Hello!', response)

    def test_repeat(self):
        response = self.client.repeat('Yellow Submarine')
        self.assertEqual('You said: Yellow Submarine', response)
        
    def test_about(self):
        response = self.client.about()
        self.assertIn('Testlink API', response)

    def test_doesUserExist_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '10000.*Big Bird'):
            self.client.doesUserExist('Big Bird')
        
    def test_createTestProject_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7001.*Empty name'):
            self.client.createTestProject(testprojectname='', 
                                                 testcaseprefix='P4711')
 
    def test_getProjects(self):
        response = self.client.getProjects()
        self.assertIsNotNone(response)
         
    def test_createTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4712'):
            self.client.createTestPlan('plan 4711', 'project 4712')
 
    def test_createTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.createTestSuite( 4711, 'suite 4712', 'detail 4713')
        
    def test_createTestCase_unknownID(self):
        tc_steps = []
        with self.assertRaisesRegexp(TLResponseError, '7000.*4713'):
            self.client.createTestCase('case 4711', 4712, 4713, 
                                        'Big Bird', 'summary 4714', tc_steps)
 
    def test_getBuildsForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getBuildsForTestPlan(4711)
         
    def test_getFirstLevelTestSuitesForTestProject_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getFirstLevelTestSuitesForTestProject(4711)
 
    def test_getFullPath_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, 'getFullPath.*234'):
            self.client.getFullPath('4711')
 
    def test_getLastExecutionResult_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getLastExecutionResult(4711, testcaseid=4712)
         
    def test_getLatestBuildForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getLatestBuildForTestPlan(4711)
         
    def test_getProjectTestPlans_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getProjectTestPlans(4711)
         
    def test_getTestCase_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.getTestCase(testcaseid=4711)
         
    def test_getTestCase_unknownExternalID(self):
        with self.assertRaisesRegexp(TLResponseError, '5040.*GPROAPI-4711'):
            self.client.getTestCase(testcaseexternalid='GPROAPI-4711')
         
    def test_getTestCaseAttachments_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.getTestCaseAttachments(testcaseid=4711)
         
    def test_getTestCaseCustomFieldDesignValue_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7000.*4711'):
            self.client.getTestCaseCustomFieldDesignValue(
                   'TC-4712', 1, 4711, 'a_field', details='a_detail')
         
    def test_getTestCaseIDByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5030.*Cannot find'):
            self.client.getTestCaseIDByName('Big Bird')
 
    def test_getTestCasesForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestCasesForTestPlan(4711)
 
    def test_getTestCasesForTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestCasesForTestSuite(4711)
 
    def test_getTestPlanByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.getTestPlanByName('project 4711', 'plan 4712')
 
    def test_getTestPlanPlatforms_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestPlanPlatforms(4711)
 
    def test_getTestProjectByName_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '7011.*4711'):
            self.client.getTestProjectByName('project 4711')
 
    def test_getTestSuiteByID_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestSuiteByID(4711)
 
    def test_getTestSuitesForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTestSuitesForTestPlan(4711)
 
    def test_getTestSuitesForTestSuite_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '8000.*4711'):
            self.client.getTestSuitesForTestSuite(4711)
 
    def test_getTotalsForTestPlan_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.getTotalsForTestPlan(4711)
 
    def test_createBuild_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '3000.*4711'):
            self.client.createBuild(4711, 'Build 4712', buildnotes='note 4713')
 
    def test_reportTCResult_unknownID(self):
        with self.assertRaisesRegexp(TLResponseError, '5000.*4711'):
            self.client.reportTCResult(4712, 'p', testcaseid=4711, 
                                       buildname='build 4713', notes='note 4714' )
 
    def test_uploadExecutionAttachment_unknownID(self):
        attachemantFile = open(os.path.realpath(__file__), 'r')
        with self.assertRaisesRegexp(TLResponseError, '6004.*4712'):
            self.client.uploadExecutionAttachment(attachemantFile, 4712, 
                        title='title 4713', description='descr. 4714')
예제 #10
0
class TestLinkAPIGenericOfflineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIGeneric - does not interacts with a TestLink Server.
    works with DummyAPIGeneric which returns special test data
    """
    def setUp(self):
        self.api = TestLinkHelper().connect(DummyAPIGeneric)
        self.callArgs = None


#    def tearDown(self):
#        pass

    def test_convertPositionalArgs(self):
        response = self.api._convertPostionalArgs('DummyMethod', [1, 2, 3])
        self.assertEqual({'Uno': 1, 'due': 2, 'tre': 3}, response)

    def test__convertPositionalArgs_missingConf(self):
        client = self.api

        def a_func(a_api):
            a_api._convertPostionalArgs('NoConfigMethod', [1, 2])

        self.assertRaises(TLArgError, a_func, client)

    def test__convertPositionalArgs_lessValues(self):
        client = self.api

        def a_func(a_api):
            a_api._convertPostionalArgs('DummyMethod', [1, 2])

        self.assertRaises(TLArgError, a_func, client)

    def test__convertPositionalArgs_moreValues(self):
        client = self.api

        def a_func(a_api):
            a_api._convertPostionalArgs('DummyMethod', [1, 2, 3, 4])

        self.assertRaises(TLArgError, a_func, client)

    def test_callServerWithPosArgs_pos(self):
        self.api.callServerWithPosArgs('DummyMethod', 1, 2, 3)
        self.assertEqual({'Uno': 1, 'due': 2, 'tre': 3}, self.api.callArgs)

    def test_callServerWithPosArgs_pos_opt(self):
        self.api.callServerWithPosArgs('DummyMethod', 1, 2, 3, quad=4)
        self.assertEqual({
            'Uno': 1,
            'due': 2,
            'tre': 3,
            'quad': 4
        }, self.api.callArgs)

    def test_callServerWithPosArgs_opt(self):
        self.api.callServerWithPosArgs('DummyMethod', quad=4)
        self.assertEqual({'quad': 4}, self.api.callArgs)

    def test_callServerWithPosArgs_none(self):
        self.api.callServerWithPosArgs('DummyMethod')
        self.assertEqual({}, self.api.callArgs)

    def test_checkResponse_emptyResponse(self):
        client = self.api

        def a_func(a_api, response):
            a_api._checkResponse(response, 'DummyMethod', {
                'Uno': 1,
                'due': 2,
                'tre': 3
            })

        self.assertRaises(TLResponseError, a_func, client, '')
        self.assertRaises(TLResponseError, a_func, client, [])

    def test_checkResponse_errorResponse(self):
        client = self.api
        responseA = [{
            'message': '(reportTCResult) - TC ID 709 does not exist!',
            'code': 5000
        }]

        def a_func(a_api, response):
            a_api._checkResponse(response, 'DummyMethod', {
                'Uno': 1,
                'due': 2,
                'tre': 3
            })

        self.assertRaises(TLResponseError, a_func, client, responseA)

    def test_checkResponse_okResponse(self):
        self.api._checkResponse(
            [{
                'message': 'all fine, cause no key with name code'
            }], 'DummyMethod', {
                'Uno': 1,
                'due': 2,
                'tre': 3
            })
        self.api._checkResponse(
            'some API Call juts returns one string without codes',
            'DummyMethod', {
                'Uno': 1,
                'due': 2,
                'tre': 3
            })

    def test_checkResponse_booleanResponse(self):
        response = True
        self.api._checkResponse(response, 'DummyMethod', {
            'Uno': 1,
            'due': 2,
            'tre': 3
        })

    def test_checkResponse_dictionaryResponse(self):
        response = {
            'note': 'uploadAttachment Calls return {..} and not [{..}]'
        }
        self.api._checkResponse(response, 'DummyMethod', {
            'Uno': 1,
            'due': 2,
            'tre': 3
        })

    def test_checkResponse_errorResponse_sringCode(self):
        client = self.api

        responseA = [{
            'message': '(getUserByID) - Cannot Find User with DB ID (4711).',
            'code': 'NO_USER_BY_ID_LOGIN'
        }]

        def a_func(a_api, response):
            a_api._checkResponse(response, 'getUserByID', {'userid': 4711})

        self.assertRaises(TLResponseError, a_func, client, responseA)

    def test__apiMethodArgNames_noArgs(self):
        response = self.api._apiMethodArgNames('sayHello')
        self.assertEqual(response, ([], [], []))

    def test_whatArgs_noArgs(self):
        response = self.api.whatArgs('sayHello')
        self.assertRegexpMatches(response, 'sayHello().*')

    def test__apiMethodArgNames_onlyOptionalArgs(self):
        response = self.api._apiMethodArgNames('getTestCaseAttachments')
        self.assertEqual(response[0], [])
        self.assertGreater(len(response[1]), 0)
        self.assertEqual(response[2], [])

    def test_whatArgs_onlyOptionalArgs(self):
        response = self.api.whatArgs('getTestCaseAttachments')
        self.assertRegexpMatches(response,
                                 'getTestCaseAttachments\(\[.*=<.*>\].*\).*')

    def test__apiMethodArgNames__OptionalAndPositionalArgs(self):
        response = self.api._apiMethodArgNames('createBuild')
        self.assertGreater(len(response[0]), 0)
        self.assertGreater(len(response[1]), 0)
        self.assertEqual(response[2], [])

    def test_whatArgs_OptionalAndPositionalArgs(self):
        response = self.api.whatArgs('createBuild')
        self.assertRegexpMatches(response, 'createBuild\(<.*>.*\).*')

    def test__apiMethodArgNames__MandatoryArgs(self):
        response = self.api._apiMethodArgNames('uploadExecutionAttachment')
        self.assertGreater(len(response[0]), 0)
        self.assertGreater(len(response[1]), 0)
        self.assertGreater(len(response[2]), 0)

    def test_whatArgs_MandatoryArgs(self):
        response = self.api.whatArgs('uploadExecutionAttachment')
        self.assertRegexpMatches(
            response,
            'uploadExecutionAttachment\(<attachmentfile>, <.*>.*\).*')

    def test_whatArgs_unknownMethods(self):
        response = self.api.whatArgs('apiUnknown')
        self.assertRegexpMatches(
            response,
            "callServerWithPosArgs\('apiUnknown', \[apiArg=<apiArg>\]\)")

    def test_noWrapperName_apiMethods(self):
        " decorator test: API Methods internal function name should be unchanged "

        # apiMethod with decorator @decoApiCallWithoutArgs
        self.assertEqual('sayHello', self.api.sayHello.__name__)
        # apiMethod with decorator @decoApiCallWithArgs
        self.assertEqual('repeat', self.api.repeat.__name__)
        # apiMethod with decorator @decoApiCallAddDevKey
        self.assertEqual('createBuild', self.api.createBuild.__name__)
        # apiMethod with decorator @decoMakerApiCallReplaceTLResponseError()
        self.assertEqual('getProjectTestPlans',
                         self.api.getProjectTestPlans.__name__)
        # apiMethod with decorator @decoApiCallAddAttachment
        self.assertEqual('uploadExecutionAttachment',
                         self.api.uploadExecutionAttachment.__name__)

    def test_ping(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.ping()
        self.assertEqual('Hey Folks!', response)

    def test_getProjectTestPlans_noPlan(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectTestPlans('noPlan')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getProjectTestPlans_onePlan(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectTestPlans('onePlan')
        self.assertEqual('21', response[0]['testproject_id'])
        self.assertEqual(1, len(response))

    def test_getProjectPlatforms_noPlatform(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectPlatforms('noPlatform')
        self.assertEqual({}, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getProjectPlatforms_twoPlatforms(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectPlatforms('twoPlatforms')
        self.assertEqual('1', response['dutch']['id'])
        self.assertEqual(2, len(response))

    def test_getBuildsForTestPlan_noBuild(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getBuildsForTestPlan('noBuild')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestPlanPlatforms_noPlatform(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestPlanPlatforms('noPlatform')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestPlanPlatforms_twoPlatforms(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestPlanPlatforms('twoPlatforms')
        self.assertEqual('dutch', response[0]['name'])
        self.assertEqual(2, len(response))

    def test_getTestSuitesForTestPlan_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestSuitesForTestPlan('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestSuitesForTestSuite_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestSuitesForTestSuite('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getFirstLevelTestSuitesForTestProject_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getFirstLevelTestSuitesForTestProject('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCasesForTestSuite_noTestCase(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCasesForTestSuite('noTestCase')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCasesForTestPlan_noTestCase(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCasesForTestPlan('noTestCase')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCaseIDByName_dictResult(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCaseIDByName(
            'dictResult', testprojectname='NEW_PROJECT_API')
        self.assertEqual(dict, type(response))
        self.assertEqual('TESTCASE_B', response['1']['name'])
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_getTestCaseIDByName_listResult(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCaseIDByName('listResult')
        self.assertEqual(list, type(response))
        self.assertEqual('TESTCASE_AA', response[0]['name'])
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_testLinkVersion_beforeTL199(self):
        self.api.loadScenario(SCENARIO_TL198)
        response = self.api.testLinkVersion()
        self.assertEqual('<= 1.9.8', response)

    def test_testLinkVersion_withTL199(self):
        self.api.loadScenario(SCENARIO_TL199)
        response = self.api.testLinkVersion()
        self.assertEqual('1.9.9', response)

    def test_connectionInfo_beforeTL199(self):
        self.api.loadScenario(SCENARIO_TL198)
        response = self.api.connectionInfo()
        self.assertRegexpMatches(response, '\d*\.\d*\.\d*')
class TestLinkAPIGenericOfflineTestCase(unittest.TestCase):
    """ TestCases for TestlinkAPIGeneric - does not interacts with a TestLink Server.
    works with DummyAPIGeneric which returns special test data
    """

    def setUp(self):
        self.api = TestLinkHelper().connect(DummyAPIGeneric)
        self.callArgs = None
        
#    def tearDown(self):
#        pass


    def test_convertPositionalArgs(self):
        response = self.api._convertPostionalArgs('DummyMethod',  [1,2,3])
        self.assertEqual({'Uno' : 1, 'due' :2, 'tre' : 3}, response)
        
    def test__convertPositionalArgs_missingConf(self):
        client = self.api
        def a_func(a_api): a_api._convertPostionalArgs('NoConfigMethod',  [1,2])
        self.assertRaises(TLArgError, a_func, client)
        
    def test__convertPositionalArgs_lessValues(self):
        client = self.api
        def a_func(a_api): a_api._convertPostionalArgs('DummyMethod',  [1,2])
        self.assertRaises(TLArgError, a_func, client)
        
    def test__convertPositionalArgs_moreValues(self):
        client = self.api
        def a_func(a_api): a_api._convertPostionalArgs('DummyMethod',  [1,2,3,4])
        self.assertRaises(TLArgError, a_func, client)

    def test_callServerWithPosArgs_pos(self):
        self.api.callServerWithPosArgs('DummyMethod',  1,2,3)
        self.assertEqual({'Uno' : 1, 'due' :2, 'tre' : 3}, self.api.callArgs)

    def test_callServerWithPosArgs_pos_opt(self):
        self.api.callServerWithPosArgs('DummyMethod',  1,2,3, quad=4)
        self.assertEqual({'Uno' : 1, 'due' :2, 'tre' : 3, 'quad' : 4}, self.api.callArgs)

    def test_callServerWithPosArgs_opt(self):
        self.api.callServerWithPosArgs('DummyMethod',  quad=4)
        self.assertEqual({'quad' : 4}, self.api.callArgs)

    def test_callServerWithPosArgs_none(self):
        self.api.callServerWithPosArgs('DummyMethod')
        self.assertEqual({}, self.api.callArgs)
        
    def test_checkResponse_emptyResponse(self):
        client = self.api
        def a_func(a_api, response): 
            a_api._checkResponse(response, 'DummyMethod',  
                                 {'Uno' : 1, 'due' :2, 'tre' : 3})
        self.assertRaises(TLResponseError, a_func, client, '')
        self.assertRaises(TLResponseError, a_func, client, [])
        
    def test_checkResponse_errorResponse(self):
        client = self.api
        responseA = [{'message': '(reportTCResult) - TC ID 709 does not exist!', 
                      'code': 5000}]
        def a_func(a_api, response): 
            a_api._checkResponse(response, 'DummyMethod',  
                                 {'Uno' : 1, 'due' :2, 'tre' : 3})
        self.assertRaises(TLResponseError, a_func, client, responseA)

    def test_checkResponse_okResponse(self):
        self.api._checkResponse(
                        [{'message': 'all fine, cause no key with name code'}],
                         'DummyMethod', {'Uno' : 1, 'due' :2, 'tre' : 3})
        self.api._checkResponse(
                        'some API Call juts returns one string without codes',
                         'DummyMethod', {'Uno' : 1, 'due' :2, 'tre' : 3})
        
    def test_checkResponse_booleanResponse(self):
        response = True
        self.api._checkResponse(response, 'DummyMethod', 
                                {'Uno' : 1, 'due' :2, 'tre' : 3})
        
    def test_checkResponse_dictionaryResponse(self):
        response = {'note' : 'uploadAttachment Calls return {..} and not [{..}]'}
        self.api._checkResponse(response, 'DummyMethod', 
                                {'Uno' : 1, 'due' :2, 'tre' : 3})
        
    def test_checkResponse_errorResponse_sringCode(self):
        client = self.api
        
        responseA = [{'message': '(getUserByID) - Cannot Find User with DB ID (4711).', 
                      'code': 'NO_USER_BY_ID_LOGIN'}]
        def a_func(a_api, response): 
            a_api._checkResponse(response, 'getUserByID',  
                                 {'userid' : 4711})
        self.assertRaises(TLResponseError, a_func, client, responseA)

    def test__apiMethodArgNames_noArgs(self):
        response = self.api._apiMethodArgNames('sayHello')
        self.assertEqual(response, ([], [], []))

    def test_whatArgs_noArgs(self):
        response = self.api.whatArgs('sayHello')
        self.assertRegexpMatches(response, 'sayHello().*')
        
    def test__apiMethodArgNames_onlyOptionalArgs(self):
        response = self.api._apiMethodArgNames('getTestCaseAttachments')
        self.assertEqual(response[0], [])
        self.assertGreater(len(response[1]), 0)
        self.assertEqual(response[2], [])

    def test_whatArgs_onlyOptionalArgs(self):
        response = self.api.whatArgs('getTestCaseAttachments')
        self.assertRegexpMatches(response, 'getTestCaseAttachments\(\[.*=<.*>\].*\).*')
        
    def test__apiMethodArgNames__OptionalAndPositionalArgs(self):
        response = self.api._apiMethodArgNames('createBuild')
        self.assertGreater(len(response[0]), 0)
        self.assertGreater(len(response[1]), 0)
        self.assertEqual(response[2], [])

    def test_whatArgs_OptionalAndPositionalArgs(self):
        response = self.api.whatArgs('createBuild')
        self.assertRegexpMatches(response, 'createBuild\(<.*>.*\).*')

    def test__apiMethodArgNames__MandatoryArgs(self):
        response = self.api._apiMethodArgNames('uploadExecutionAttachment')
        self.assertGreater(len(response[0]), 0)
        self.assertGreater(len(response[1]), 0)
        self.assertGreater(len(response[2]), 0)

    def test_whatArgs_MandatoryArgs(self):
        response = self.api.whatArgs('uploadExecutionAttachment')
        self.assertRegexpMatches(response, 
                    'uploadExecutionAttachment\(<attachmentfile>, <.*>.*\).*')

    def test_whatArgs_unknownMethods(self):
        response = self.api.whatArgs('apiUnknown')
        self.assertRegexpMatches(response, 
                "callServerWithPosArgs\('apiUnknown', \[apiArg=<apiArg>\]\)")
        
    def test_noWrapperName_apiMethods(self):
        " decorator test: API Methods internal function name should be unchanged "
        
        # apiMethod with decorator @decoApiCallWithoutArgs
        self.assertEqual('sayHello', self.api.sayHello.__name__)
        # apiMethod with decorator @decoApiCallWithArgs
        self.assertEqual('repeat', self.api.repeat.__name__)
        # apiMethod with decorator @decoApiCallAddDevKey 
        self.assertEqual('createBuild', self.api.createBuild.__name__)
        # apiMethod with decorator @decoMakerApiCallReplaceTLResponseError()
        self.assertEqual('getProjectTestPlans', self.api.getProjectTestPlans.__name__)
        # apiMethod with decorator @decoApiCallAddAttachment
        self.assertEqual('uploadExecutionAttachment', self.api.uploadExecutionAttachment.__name__)
        
    def test_ping(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.ping()
        self.assertEqual('Hey Folks!', response)
        
        
    def test_getProjectTestPlans_noPlan(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectTestPlans('noPlan')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getProjectTestPlans_onePlan(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectTestPlans('onePlan')
        self.assertEqual('21', response[0]['testproject_id'])
        self.assertEqual(1, len(response))
        
    def test_getProjectPlatforms_noPlatform(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectPlatforms('noPlatform')
        self.assertEqual({}, response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getProjectPlatforms_twoPlatforms(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getProjectPlatforms('twoPlatforms')
        self.assertEqual('1', response['dutch']['id'])
        self.assertEqual(2, len(response))
        
        
    def test_getBuildsForTestPlan_noBuild(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getBuildsForTestPlan('noBuild')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestPlanPlatforms_noPlatform(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestPlanPlatforms('noPlatform')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestPlanPlatforms_twoPlatforms(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestPlanPlatforms('twoPlatforms')
        self.assertEqual('dutch', response[0]['name'])
        self.assertEqual(2, len(response))

    def test_getTestSuitesForTestPlan_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestSuitesForTestPlan('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
       
    def test_getTestSuitesForTestSuite_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestSuitesForTestSuite('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getFirstLevelTestSuitesForTestProject_noSuite(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getFirstLevelTestSuitesForTestProject('noSuite')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestCasesForTestSuite_noTestCase(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCasesForTestSuite('noTestCase')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
           
    def test_getTestCasesForTestPlan_noTestCase(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCasesForTestPlan('noTestCase')
        self.assertEqual([], response)
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestCaseIDByName_dictResult(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCaseIDByName('dictResult', 
                                            testprojectname='NEW_PROJECT_API')
        self.assertEqual(dict, type(response))
        self.assertEqual('TESTCASE_B', response['1']['name']) 
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])
        
    def test_getTestCaseIDByName_listResult(self):
        self.api.loadScenario(SCENARIO_A)
        response = self.api.getTestCaseIDByName('listResult')
        self.assertEqual(list, type(response))
        self.assertEqual('TESTCASE_AA', response[0]['name']) 
        self.assertEqual(self.api.devKey, self.api.callArgs['devKey'])

    def test_testLinkVersion_beforeTL199(self):
        self.api.loadScenario(SCENARIO_TL198)
        response = self.api.testLinkVersion()
        self.assertEqual('<= 1.9.8', response)
        
    def test_testLinkVersion_withTL199(self):
        self.api.loadScenario(SCENARIO_TL199)
        response = self.api.testLinkVersion()
        self.assertEqual('1.9.9', response)
        
    def test_connectionInfo_beforeTL199(self):
        self.api.loadScenario(SCENARIO_TL198)
        response = self.api.connectionInfo()
        self.assertRegexpMatches(response, '\d*\.\d*\.\d*')