diff options
Diffstat (limited to 'testapi/testapi-client')
51 files changed, 3534 insertions, 34 deletions
diff --git a/testapi/testapi-client/etc/client.creds b/testapi/testapi-client/etc/client.creds index a082047..ee2a0ab 100644 --- a/testapi/testapi-client/etc/client.creds +++ b/testapi/testapi-client/etc/client.creds @@ -1,3 +1,4 @@ export testapi_url=http://localhost:8000/api/v1 export testapi_cas_signin_return=/auth/signin_return -export testapi_cas_auth_url=https://identity.linuxfoundation.org/user/login?destination=cas/login%3Fservice%3D
\ No newline at end of file +export testapi_cas_auth_url=https://identity.linuxfoundation.org/user/login?destination=cas/login%3Fservice%3D +export testapi_token=changeme
\ No newline at end of file diff --git a/testapi/testapi-client/setup.cfg b/testapi/testapi-client/setup.cfg index 72a5a57..ee1ba54 100644 --- a/testapi/testapi-client/setup.cfg +++ b/testapi/testapi-client/setup.cfg @@ -26,6 +26,48 @@ testapi = project delete = testapiclient.cli.projects:ProjectDelete project put = testapiclient.cli.projects:ProjectPut + testcase create = testapiclient.cli.testcases:TestcaseCreate + testcase get = testapiclient.cli.testcases:TestcaseGet + testcase getone = testapiclient.cli.testcases:TestcaseGetOne + testcase delete = testapiclient.cli.testcases:TestcaseDelete + testcase put = testapiclient.cli.testcases:TestcasePut + + scenario create = testapiclient.cli.scenarios:ScenarioCreate + scenario get = testapiclient.cli.scenarios:ScenarioGet + scenario getone = testapiclient.cli.scenarios:ScenarioGetOne + scenario delete = testapiclient.cli.scenarios:ScenarioDelete + scenario put = testapiclient.cli.scenarios:ScenarioPut + + scenario installer create = testapiclient.cli.scenarios:InstallerCreate + scenario installer delete = testapiclient.cli.scenarios:InstallerDelete + scenario installer put = testapiclient.cli.scenarios:InstallerPut + + scenario version create = testapiclient.cli.scenarios:VersionCreate + scenario version delete = testapiclient.cli.scenarios:VersionDelete + scenario version put = testapiclient.cli.scenarios:VersionPut + + scenario version owner put = testapiclient.cli.scenarios:VersionOwnerPut + + scenario project create = testapiclient.cli.scenarios:ProjectCreate + scenario project delete = testapiclient.cli.scenarios:ProjectDelete + scenario project put = testapiclient.cli.scenarios:ProjectPut + + scenario custom create = testapiclient.cli.scenarios:CustomCreate + scenario custom delete = testapiclient.cli.scenarios:CustomDelete + scenario custom put = testapiclient.cli.scenarios:CustomPut + + scenario trustindicator create = testapiclient.cli.scenarios:TrustIndicatorCreate + + scenario score create = testapiclient.cli.scenarios:ScoreCreate + + deployresult create = testapiclient.cli.deployresults:DeployresultCreate + deployresult get = testapiclient.cli.deployresults:DeployresultGet + deployresult getone = testapiclient.cli.deployresults:DeployresultGetOne + + result create = testapiclient.cli.results:ResultCreate + result get = testapiclient.cli.results:ResultGet + result getone = testapiclient.cli.results:ResultGetOne + [egg_info] tag_build = tag_date = 0 diff --git a/testapi/testapi-client/testapiclient/cli/deployresults.py b/testapi/testapi-client/testapiclient/cli/deployresults.py new file mode 100644 index 0000000..1ca0bef --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/deployresults.py @@ -0,0 +1,98 @@ +import json + +from testapiclient.utils import command +from testapiclient.utils import urlparse +from testapiclient.models import deployresult + + +def deployresults_url(): + return urlparse.resource_join('deployresults') + + +def deployresult_url(parsed_args): + return urlparse.path_join(deployresults_url(), parsed_args.deployresult_id) + + +class DeployresultGet(command.Lister): + + def get_parser(self, prog_name): + parser = super(DeployresultGet, self).get_parser(prog_name) + parser.add_argument('-build-id', + help='Search deployresults using build tag') + parser.add_argument('-from', + help='Search deployresults using from date') + parser.add_argument('-scenario', + help='Search deployresults using scenario') + parser.add_argument('-period', + help='Search deployresults using period') + parser.add_argument('-page', + help='Search deployresults using page') + parser.add_argument('-to', + help='Search deployresults using to') + parser.add_argument('---version', + help='Search deployresults using version') + parser.add_argument('-last', + help='Search deployresults using last date') + parser.add_argument('-pod-name', + help='Search deployresults using pod') + parser.add_argument('-criteria', + help='Search deployresults using version') + parser.add_argument('-installer', + help='Search deployresults using installer') + parser.add_argument('-job-name', + help='Search deployresults using project') + + return parser + + def take_action(self, parsed_args): + columns = ( + '_id', + 'pod_name', + 'version', + 'criteria', + 'start_date', + 'stop_date', + 'scenario', + 'installer', + + ) + data = self.app.client_manager.get( + urlparse.query_by(deployresults_url(), + ['build_id', 'from', 'last', + 'scenario', 'period', 'job_name', + 'to', 'version', + 'criteria', 'installer', 'pod_name', 'page'], + parsed_args)) + return self.format_output(columns, data.get('deployresults', [])) + + +class DeployresultGetOne(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(DeployresultGetOne, self).get_parser(prog_name) + parser.add_argument('deployresult_id', + help='Search deployresult by deployresult id') + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.get(deployresult_url(parsed_args))) + + +class DeployresultCreate(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(DeployresultCreate, self).get_parser(prog_name) + parser.add_argument('deployresult', + type=json.loads, + help='Deployresult create request format:\n' + '\'{}\''.format(json.dumps( + deployresult.DeployResultCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.post( + deployresults_url(), parsed_args.deployresult)) diff --git a/testapi/testapi-client/testapiclient/cli/pods.py b/testapi/testapi-client/testapiclient/cli/pods.py index 8d0970b..a7706f6 100644 --- a/testapi/testapi-client/testapiclient/cli/pods.py +++ b/testapi/testapi-client/testapiclient/cli/pods.py @@ -1,7 +1,9 @@ import json +from testapiclient.client import pods from testapiclient.utils import command from testapiclient.utils import urlparse +from testapiclient.models import pods as pm def pods_url(): @@ -60,15 +62,17 @@ class PodCreate(command.ShowOne): parser.add_argument('pod', type=json.loads, help='Pod create request format :\n' - '\'{"role": "", "name": "", "details": "", ' - '"mode": ""}\',\n role should be either ' + '\'{}\''.format(json.dumps( + pm.PodCreateRequest().__dict__ + )) + + '\n role should be either ' '"community-ci" or "production-ci", and ' 'mode should be either "metal" or "virtual.') return parser def take_action(self, parsed_args): - return self.format_output( - self.app.client_manager.post(pods_url(), parsed_args.pod)) + client = pods.PodsClient(client_manager=self.app.client_manager) + return self.format_output(client.create(parsed_args.pod)) class PodDelete(command.Command): diff --git a/testapi/testapi-client/testapiclient/cli/projects.py b/testapi/testapi-client/testapiclient/cli/projects.py index 510acc8..2fa5b5b 100644 --- a/testapi/testapi-client/testapiclient/cli/projects.py +++ b/testapi/testapi-client/testapiclient/cli/projects.py @@ -2,6 +2,7 @@ import json from testapiclient.utils import command from testapiclient.utils import urlparse +from testapiclient.models import project def projects_url(): @@ -51,9 +52,10 @@ class ProjectCreate(command.ShowOne): parser = super(ProjectCreate, self).get_parser(prog_name) parser.add_argument('project', type=json.loads, - help='Project create request format :{' - ' "name": (required)"", ' - '"description": (optional)""}') + help='Project create request format :\n' + '\'{}\''.format(json.dumps( + project.ProjectCreateRequest().__dict__ + ))) return parser def take_action(self, parsed_args): @@ -83,9 +85,10 @@ class ProjectPut(command.ShowOne): help='Update project by name') parser.add_argument('project', type=json.loads, - help='Project Update request format :{' - '"name": (required)"", ' - '"description": (optional)""}') + help='Project Update request format :\n' + '\'{}\''.format(json.dumps( + project.ProjectCreateRequest().__dict__ + ))) return parser def take_action(self, parsed_args): diff --git a/testapi/testapi-client/testapiclient/cli/results.py b/testapi/testapi-client/testapiclient/cli/results.py new file mode 100644 index 0000000..5500501 --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/results.py @@ -0,0 +1,97 @@ +import json + +from testapiclient.utils import command +from testapiclient.utils import urlparse +from testapiclient.models import result + + +def results_url(): + return urlparse.resource_join('results') + + +def result_url(parsed_args): + return urlparse.path_join(results_url(), parsed_args.result_id) + + +class ResultGet(command.Lister): + + def get_parser(self, prog_name): + parser = super(ResultGet, self).get_parser(prog_name) + parser.add_argument('-case', + help='Search results using tesetcase') + parser.add_argument('-build-tag', + help='Search results using build tag') + parser.add_argument('-from', + help='Search results using from date') + parser.add_argument('-last', + help='Search results using last date') + parser.add_argument('-scenario', + help='Search results using scenario') + parser.add_argument('-period', + help='Search results using period') + parser.add_argument('-project', + help='Search results using project') + parser.add_argument('-to', + help='Search results using to') + parser.add_argument('---version', + help='Search results using version') + parser.add_argument('-criteria', + help='Search results using version') + parser.add_argument('-installer', + help='Search results using installer') + parser.add_argument('-pod', + help='Search results using pod') + parser.add_argument('-page', + help='Search results using page') + return parser + + def take_action(self, parsed_args): + columns = ( + '_id', + 'pod_name', + 'project_name', + 'case_name', + 'installer', + 'version', + 'scenario', + 'criteria', + 'start_date' + ) + data = self.app.client_manager.get( + urlparse.query_by(results_url(), + ['case', 'build_tag', 'from', 'last', + 'scenario', 'period', 'project', + 'to', 'version', + 'criteria', 'installer', 'pod', 'page'], + parsed_args)) + return self.format_output(columns, data.get('results', [])) + + +class ResultGetOne(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ResultGetOne, self).get_parser(prog_name) + parser.add_argument('result_id', + help='Search result by result id') + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.get(result_url(parsed_args))) + + +class ResultCreate(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ResultCreate, self).get_parser(prog_name) + parser.add_argument('result', + type=json.loads, + help='Result create request format:\n' + '\'{}\''.format(json.dumps( + result.ResultCreateRequest().__dict__))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.post( + results_url(), parsed_args.result)) diff --git a/testapi/testapi-client/testapiclient/cli/scenarios.py b/testapi/testapi-client/testapiclient/cli/scenarios.py new file mode 100644 index 0000000..197ee0c --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/scenarios.py @@ -0,0 +1,603 @@ +import json + +from testapiclient.utils import command +from testapiclient.utils import urlparse +from testapiclient.models import scenario + + +def scenarios_url(): + return urlparse.resource_join('scenarios') + + +def scenario_url(parsed_args): + return urlparse.path_join(scenarios_url(), parsed_args.name) + + +def resources_url(name, resuorce): + return urlparse.resource_join('scenarios', name, resuorce) + + +class ScenarioGet(command.Lister): + + def get_parser(self, prog_name): + parser = super(ScenarioGet, self).get_parser(prog_name) + parser.add_argument('-name', + help='Search scenarios using name') + parser.add_argument('-installer', + help='Search scenarios using installer') + parser.add_argument('---version', + help='Search scenarios using version') + parser.add_argument('-project', + help='Search scenarios using project') + return parser + + def take_action(self, parsed_args): + columns = ( + 'name', + '_id', + 'creator', + 'creation_date' + ) + data = self.app.client_manager.get( + urlparse.query_by(scenarios_url(), + ['name', 'installer', 'version', 'project'], + parsed_args)) + return self.format_output(columns, data.get('scenarios', [])) + + +class ScenarioGetOne(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ScenarioGetOne, self).get_parser(prog_name) + parser.add_argument('name', + help='Search scenario by name') + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.get(scenario_url(parsed_args))) + + +class ScenarioCreate(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ScenarioCreate, self).get_parser(prog_name) + parser.add_argument('scenario', + type=json.loads, + help='Scenario create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioCreateRequest( + ).__dict__ + )) + + '\n Intaller create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioInstallerCreateRequest( + ).__dict__ + )) + + '\n Version create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioVersionCreateRequest( + ).__dict__ + )) + + '\n Project create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioProjectCreateRequest( + ).__dict__ + )) + + '\n Custom create request format :\n' + '\'["asf","saf"]\',\n' + '\n Score create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioScoreCreateRequest( + ).__dict__ + )) + + '\nTrustIndicator create request format:\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioTICreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.post( + scenarios_url(), parsed_args.scenario)) + + +class ScenarioDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(ScenarioDelete, self).get_parser(prog_name) + parser.add_argument('name', + type=str, + help='Delete scenario by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete(scenario_url(parsed_args)) + + +class ScenarioPut(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ScenarioPut, self).get_parser(prog_name) + parser.add_argument('name', + type=str, + help='Update scenario by name') + parser.add_argument('scenario', + type=json.loads, + help='Scenario create request format :\n' + + '\'{}\''.format(json.dumps( + scenario.ScenarioCreateRequest( + ).__dict__ + )) + + '\n Intaller create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioInstallerCreateRequest( + ).__dict__ + )) + + '\n Version create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioVersionCreateRequest( + ).__dict__ + )) + + '\n Project create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioProjectCreateRequest( + ).__dict__ + )) + + '\n Custom create request format :\n' + '\'["asf","saf"]\',\n' + '\n Score create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioScoreCreateRequest( + ).__dict__ + )) + + '\nTrustIndicator create request format:\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioTICreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.put( + scenario_url(parsed_args), parsed_args.scenario)) + + +class InstallerCreate(command.Command): + + def get_parser(self, prog_name): + parser = super(InstallerCreate, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + required=True, + help='Create installer under scenario name') + parser.add_argument('installer', + type=json.loads, + help='Intaller create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioInstallerCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.post( + resources_url( + parsed_args.scenario_name, + 'installers'), parsed_args.installer) + + +class InstallerDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(InstallerDelete, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + required=True, + type=str, + help='Delete installer by scenario name') + parser.add_argument('name', + nargs='+', + help='Delete installer by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete( + resources_url( + parsed_args.scenario_name, + 'installers'), parsed_args.name) + + +class InstallerPut(command.Command): + + def get_parser(self, prog_name): + parser = super(InstallerPut, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Update installer by scenario name') + parser.add_argument('installer', + type=json.loads, + help='Intaller create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioInstallerCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.put( + resources_url( + parsed_args.scenario_name, + 'installers'), parsed_args.installer) + + +class VersionCreate(command.Command): + + def get_parser(self, prog_name): + parser = super(VersionCreate, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + required=True, + help='Create version under scenario name') + parser.add_argument('--installer', + required=True, + help='Create version under scenario name') + parser.add_argument('version', + type=json.loads, + help='version create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioVersionCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.post( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'versions'), + 'installer', + parsed_args), parsed_args.version) + + +class VersionDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(VersionDelete, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + required=True, + type=str, + help='Delete version by scenario name') + parser.add_argument('--installer', + required=True, + help='Create version under scenario name') + parser.add_argument('name', + nargs='+', + help='Delete version by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'versions'), + 'installer', + parsed_args), parsed_args.name) + + +class VersionPut(command.Command): + + def get_parser(self, prog_name): + parser = super(VersionPut, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Update installer by scenario name') + parser.add_argument('--installer', + required=True, + help='Update version under installer name') + parser.add_argument('version', + type=json.loads, + help='version update request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioVersionCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.put( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'versions'), + 'installer', + parsed_args), parsed_args.version) + + +class VersionOwnerPut(command.Command): + + def get_parser(self, prog_name): + parser = super(VersionOwnerPut, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Update version by scenario name') + parser.add_argument('--installer', + required=True, + help='Update version under scenario name') + parser.add_argument('--version', + required=True, + help='Update version under scenario name') + parser.add_argument('owner', + type=json.loads, + help='Intaller create request format :\n' + '\'{"owner": ""}\',\n') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.put( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'owner'), + ['installer', 'version'], + parsed_args), parsed_args.owner) + + +class ProjectCreate(command.Command): + + def get_parser(self, prog_name): + parser = super(ProjectCreate, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Create project by scenario name') + parser.add_argument('--installer', + required=True, + help='Create project under installer name') + parser.add_argument('--version', + required=True, + help='Create project under version name') + parser.add_argument('project', + type=json.loads, + help='Project create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioProjectCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.post( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'projects'), + ['installer', 'version'], + parsed_args), parsed_args.project) + + +class ProjectDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(ProjectDelete, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + required=True, + type=str, + help='Delete projects by scenario name') + parser.add_argument('--installer', + required=True, + help='Delete projects under installer name') + parser.add_argument('--version', + required=True, + help='Delete projects under version name') + parser.add_argument('name', + nargs='+', + help='Delete projects by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'projects'), + ['installer', 'version'], + parsed_args), parsed_args.name) + + +class ProjectPut(command.Command): + + def get_parser(self, prog_name): + parser = super(ProjectPut, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Update project by scenario name') + parser.add_argument('--installer', + required=True, + help='Update project under installer name') + parser.add_argument('--version', + required=True, + help='Update project under version name') + parser.add_argument('project', + type=json.loads, + help='Project update request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioProjectCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.put( + urlparse.query_by( + resources_url(parsed_args.scenario_name, 'projects'), + ['installer', 'version'], + parsed_args), parsed_args.project) + + +class CustomCreate(command.Command): + + def get_parser(self, prog_name): + parser = super(CustomCreate, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Create custom by scenario name') + parser.add_argument('--installer', + required=True, + help='Create custom under installer name') + parser.add_argument('--version', + required=True, + help='Create custom under version name') + parser.add_argument('--project', + required=True, + help='Create custom under project name') + parser.add_argument('custom', + nargs='+', + help='Space sperated strings') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.post( + urlparse.query_by( + resources_url( + parsed_args.scenario_name, + 'customs'), + ['installer', 'version', 'project'], + parsed_args), + parsed_args.custom) + + +class CustomDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(CustomDelete, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + required=True, + type=str, + help='Delete custom by scenario name') + parser.add_argument('--installer', + required=True, + help='Create custom under scenario name') + parser.add_argument('--version', + required=True, + help='Create custom under scenario name') + parser.add_argument('--project', + required=True, + help='Create custom under scenario name') + parser.add_argument('name', + nargs='+', + help='Delete custom by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete( + urlparse.query_by( + resources_url( + parsed_args.scenario_name, + 'customs'), + ['installer', 'version', 'project'], + parsed_args), + parsed_args.name) + + +class CustomPut(command.Command): + + def get_parser(self, prog_name): + parser = super(CustomPut, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Update custom by scenario name') + parser.add_argument('--installer', + required=True, + help='Update custom under installer name') + parser.add_argument('--version', + required=True, + help='Update custom under version name') + parser.add_argument('--project', + required=True, + help='Update custom under project name') + parser.add_argument('custom', + nargs='+', + help='space sperated strings') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.put( + urlparse.query_by( + resources_url( + parsed_args.scenario_name, + 'customs'), + ['installer', 'version', 'project'], + parsed_args), + parsed_args.custom) + + +class TrustIndicatorCreate(command.Command): + + def get_parser(self, prog_name): + parser = super(TrustIndicatorCreate, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Create trust indicator by scenario name') + parser.add_argument('--installer', + required=True, + help='Create trustindicator under installer name') + parser.add_argument('--version', + required=True, + help='Create trust indicator under version name') + parser.add_argument('--project', + required=True, + help='Create trust indicator under project name') + parser.add_argument('trust_indicator', + type=json.loads, + help='trust indicator create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioTICreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + print parsed_args + return self.app.client_manager.post( + urlparse.query_by( + resources_url( + parsed_args.scenario_name, + 'trust_indicators'), + ['installer', 'version', 'project'], + parsed_args), + parsed_args.trust_indicator) + + +class ScoreCreate(command.Command): + + def get_parser(self, prog_name): + parser = super(ScoreCreate, self).get_parser(prog_name) + parser.add_argument('--scenario-name', + type=str, + required=True, + help='Create score by scenario name') + parser.add_argument('--installer', + required=True, + help='Create score under installer name') + parser.add_argument('--version', + required=True, + help='Create score under version name') + parser.add_argument('--project', + required=True, + help='Create score under project name') + parser.add_argument('score', + type=json.loads, + help='score create request format :\n' + '\'{}\''.format(json.dumps( + scenario.ScenarioScoreCreateRequest( + ).__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.post( + urlparse.query_by( + resources_url( + parsed_args.scenario_name, + 'scores'), + ['installer', 'version', 'project'], + parsed_args), + parsed_args.score) diff --git a/testapi/testapi-client/testapiclient/cli/testcases.py b/testapi/testapi-client/testapiclient/cli/testcases.py new file mode 100644 index 0000000..3052c18 --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/testcases.py @@ -0,0 +1,114 @@ +import json + +from testapiclient.utils import command +from testapiclient.utils import urlparse +from testapiclient.models import testcase + + +def testcases_url(name): + return urlparse.resource_join('projects', name, 'cases') + + +def testcase_url(parsed_args): + return urlparse.path_join( + testcases_url(parsed_args.project_name), parsed_args.name) + + +class TestcaseGet(command.Lister): + + def get_parser(self, prog_name): + parser = super(TestcaseGet, self).get_parser(prog_name) + parser.add_argument('--project-name', + required=True, + help='Search testcases by project name') + return parser + + def take_action(self, parsed_args): + columns = ( + 'name', + '_id', + 'creator', + 'creation_date' + ) + data = self.app.client_manager.get( + testcases_url(parsed_args.project_name)) + return self.format_output(columns, data.get('testcases', [])) + + +class TestcaseGetOne(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(TestcaseGetOne, self).get_parser(prog_name) + parser.add_argument('--project-name', + required=True, + help='Search testcase by project name') + parser.add_argument('name', + help='Search testcase by name') + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.get(testcase_url(parsed_args))) + + +class TestcaseCreate(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(TestcaseCreate, self).get_parser(prog_name) + parser.add_argument('--project-name', + required=True, + help='Create testcase under project name') + parser.add_argument('testcase', + type=json.loads, + help='Testcase create request format:\n' + '\'{}\''.format(json.dumps( + testcase.TestCaseCreateRequest().__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.post( + testcases_url(parsed_args.project_name), parsed_args.testcase)) + + +class TestcaseDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(TestcaseDelete, self).get_parser(prog_name) + parser.add_argument('--project-name', + required=True, + type=str, + help='Delete testcase by project name') + parser.add_argument('name', + type=str, + help='Delete testcase by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete(testcase_url(parsed_args)) + + +class TestcasePut(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(TestcasePut, self).get_parser(prog_name) + parser.add_argument('--project-name', + type=str, + required=True, + help='Update testcase by project name') + parser.add_argument('name', + type=str, + help='Update testcase by name') + parser.add_argument('testcase', + type=json.loads, + help='Testcase Update request format:\n' + '\'{}\''.format(json.dumps( + testcase.TestCaseCreateRequest().__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.put( + testcase_url(parsed_args), parsed_args.testcase)) diff --git a/testapi/testapi-client/testapiclient/client/__init__.py b/testapi/testapi-client/testapiclient/client/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/__init__.py diff --git a/testapi/testapi-client/testapiclient/client/base.py b/testapi/testapi-client/testapiclient/client/base.py new file mode 100644 index 0000000..c45c9b7 --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/base.py @@ -0,0 +1,23 @@ +from testapiclient.utils import clientmanager +from testapiclient.utils import urlparse + + +class AuthOption(object): + def __init__(self, user=None, password=None): + self.u = user + self.p = password + + +class Client(object): + + resource = '' + + def __init__(self, user=None, password=None, client_manager=None): + self.url = urlparse.resource_join(self.resource) + if client_manager: + self.clientmanager = client_manager + else: + self.clientmanager = clientmanager.ClientManager( + AuthOption(user, password)) + if self.clientmanager.auth_required: + self.clientmanager.auth() diff --git a/testapi/testapi-client/testapiclient/client/deploy_results.py b/testapi/testapi-client/testapiclient/client/deploy_results.py new file mode 100644 index 0000000..b0724b0 --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/deploy_results.py @@ -0,0 +1,28 @@ +import json + +from testapiclient.client import base +from testapiclient.utils import urlparse + + +class DeployResultsClient(base.Client): + resource = 'deployresults' + + def __init__(self, **kwargs): + super(DeployResultsClient, self).__init__(**kwargs) + + def create(self, testcase_req): + return self.clientmanager.post(self.url, testcase_req) + + def get(self, **queries): + if queries: + return json.dumps( + self.clientmanager.get( + urlparse.query_join(self.url, **queries))['deployresults']) + else: + return json.dumps( + self.clientmanager.get(self.url)['deployresults']) + + def get_one(self, id): + return json.dumps( + self.clientmanager.get( + urlparse.path_join(self.url, id))) diff --git a/testapi/testapi-client/testapiclient/client/pods.py b/testapi/testapi-client/testapiclient/client/pods.py new file mode 100644 index 0000000..d08114f --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/pods.py @@ -0,0 +1,31 @@ +import json + +from testapiclient.client import base +from testapiclient.utils import urlparse + + +class PodsClient(base.Client): + resource = 'pods' + + def __init__(self, **kwargs): + super(PodsClient, self).__init__(**kwargs) + + def create(self, pod_req): + return self.clientmanager.post(self.url, pod_req) + + def get(self, **queries): + if queries: + return json.dumps( + self.clientmanager.get( + urlparse.query_join(self.url, **queries))['pods']) + else: + return json.dumps( + self.clientmanager.get(self.url)['pods']) + + def get_one(self, name): + return json.dumps(self.clientmanager.get( + urlparse.path_join(self.url, name))) + + def delete(self, name): + return self.clientmanager.delete( + urlparse.path_join(self.url, name)) diff --git a/testapi/testapi-client/testapiclient/client/projects.py b/testapi/testapi-client/testapiclient/client/projects.py new file mode 100644 index 0000000..63d00fe --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/projects.py @@ -0,0 +1,35 @@ +import json + +from testapiclient.client import base +from testapiclient.utils import urlparse + + +class ProjectsClient(base.Client): + resource = 'projects' + + def __init__(self, **kwargs): + super(ProjectsClient, self).__init__(**kwargs) + + def create(self, project_req): + return self.clientmanager.post(self.url, project_req) + + def get(self, **queries): + if queries: + return json.dumps( + self.clientmanager.get( + urlparse.query_join(self.url, **queries))['projects']) + else: + return json.dumps( + self.clientmanager.get(self.url)['projects']) + + def get_one(self, name): + return json.dumps(self.clientmanager.get( + urlparse.path_join(self.url, name))) + + def delete(self, name): + return self.clientmanager.delete( + urlparse.path_join(self.url, name)) + + def update(self, name, project_req): + return self.clientmanager.put( + urlparse.path_join(self.url, name), project_req) diff --git a/testapi/testapi-client/testapiclient/client/results.py b/testapi/testapi-client/testapiclient/client/results.py new file mode 100644 index 0000000..7d9ad0e --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/results.py @@ -0,0 +1,28 @@ +import json + +from testapiclient.client import base +from testapiclient.utils import urlparse + + +class ResultsClient(base.Client): + resource = 'results' + + def __init__(self, **kwargs): + super(ResultsClient, self).__init__(**kwargs) + + def create(self, testcase_req): + return self.clientmanager.post(self.url, testcase_req) + + def get(self, **queries): + if queries: + return json.dumps( + self.clientmanager.get( + urlparse.query_join(self.url, **queries))['results']) + else: + return json.dumps( + self.clientmanager.get(self.url)['results']) + + def get_one(self, id): + return json.dumps( + self.clientmanager.get( + urlparse.path_join(self.url, id))) diff --git a/testapi/testapi-client/testapiclient/client/scenarios.py b/testapi/testapi-client/testapiclient/client/scenarios.py new file mode 100644 index 0000000..e5ce2f1 --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/scenarios.py @@ -0,0 +1,177 @@ +import json + +from testapiclient.client import base +from testapiclient.utils import urlparse + + +class ScenariosClient(base.Client): + resource = 'scenarios' + + def __init__(self, **kwargs): + super(ScenariosClient, self).__init__(**kwargs) + + def create(self, scenario_req): + return self.clientmanager.post(self.url, scenario_req) + + def get(self, **queries): + if queries: + return json.dumps( + self.clientmanager.get( + urlparse.query_join(self.url, **queries))['scenarios']) + else: + return json.dumps( + self.clientmanager.get(self.url)['scenarios']) + + def get_one(self, scenario_name): + return json.dumps( + self.clientmanager.get( + urlparse.path_join( + self.url, scenario_name))) + + def delete(self, scenario_name): + return self.clientmanager.delete( + urlparse.path_join( + self.url, scenario_name)) + + def update(self, scenario_name, scenario_req): + return self.clientmanager.put( + urlparse.path_join( + self.url, scenario_name), scenario_req) + + +class InstallersClient(base.Client): + resource = 'scenarios/{}/installers' + + def __init__(self, **kwargs): + super(InstallersClient, self).__init__(**kwargs) + + def delete(self, scenario_name, name): + return self.clientmanager.delete( + self.url.format(scenario_name), [name]) + + def update(self, scenario_name, installer_req): + return self.clientmanager.put( + self.url.format(scenario_name), installer_req) + + def create(self, scenario_name, installer_req): + return self.clientmanager.post( + self.url.format(scenario_name), installer_req) + + +class VersionsClient(base.Client): + resource = 'scenarios/{}/versions' + + def __init__(self, **kwargs): + super(VersionsClient, self).__init__(**kwargs) + + def delete(self, scenario_name, installer, name): + queries = {'installer': installer} + return self.clientmanager.delete( + urlparse.query_join( + self.url.format(scenario_name), **queries), name) + + def update(self, scenario_name, installer, version_req): + queries = {'installer': installer} + return self.clientmanager.put( + urlparse.query_join( + self.url.format(scenario_name), **queries), version_req) + + def create(self, scenario_name, installer, version_req): + queries = {'installer': installer} + return self.clientmanager.post( + urlparse.query_join( + self.url.format(scenario_name), **queries), version_req) + + +class VersionsOwnerClient(base.Client): + resource = 'scenarios/{}/owner' + + def __init__(self, **kwargs): + super(VersionsOwnerClient, self).__init__(**kwargs) + + def update(self, scenario_name, installer, version, owner): + queries = {'installer': installer, 'version': version} + return self.clientmanager.put( + urlparse.query_join( + self.url.format(scenario_name), **queries), owner) + + +class ProjectsClient(base.Client): + resource = 'scenarios/{}/projects' + + def __init__(self, **kwargs): + super(ProjectsClient, self).__init__(**kwargs) + + def delete(self, scenario_name, installer, version, name): + queries = {'installer': installer, 'version': version} + return self.clientmanager.delete( + urlparse.query_join( + self.url.format(scenario_name), **queries), name) + + def update(self, scenario_name, installer, version, project_req): + queries = {'installer': installer, 'version': version} + return self.clientmanager.put( + urlparse.query_join( + self.url.format(scenario_name), **queries), project_req) + + def create(self, scenario_name, installer, version, project_req): + queries = {'installer': installer, 'version': version} + return self.clientmanager.post( + urlparse.query_join( + self.url.format(scenario_name), **queries), project_req) + + +class TrustIndicatorsClient(base.Client): + resource = 'scenarios/{}/trust_indicators' + + def __init__(self, **kwargs): + super(TrustIndicatorsClient, self).__init__(**kwargs) + + def create(self, scenario_name, installer, version, project, trust_in_req): + queries = { + 'installer': installer, 'version': version, 'project': project} + return self.clientmanager.post( + urlparse.query_join( + self.url.format(scenario_name), **queries), trust_in_req) + + +class ScoresClient(base.Client): + resource = 'scenarios/{}/scores' + + def __init__(self, **kwargs): + super(ScoresClient, self).__init__(**kwargs) + + def create(self, scenario_name, installer, version, project, scores_req): + queries = { + 'installer': installer, 'version': version, 'project': project} + return self.clientmanager.post( + urlparse.query_join( + self.url.format(scenario_name), **queries), scores_req) + + +class CustomsClient(base.Client): + resource = 'scenarios/{}/customs' + + def __init__(self, **kwargs): + super(CustomsClient, self).__init__(**kwargs) + + def delete(self, scenario_name, installer, version, project, customs): + queries = { + 'installer': installer, 'version': version, 'project': project} + return self.clientmanager.delete( + urlparse.query_join( + self.url.format(scenario_name), **queries), customs) + + def update(self, scenario_name, installer, version, project, customs): + queries = { + 'installer': installer, 'version': version, 'project': project} + return self.clientmanager.put( + urlparse.query_join( + self.url.format(scenario_name), **queries), customs) + + def create(self, scenario_name, installer, version, project, customs): + queries = { + 'installer': installer, 'version': version, 'project': project} + return self.clientmanager.post( + urlparse.query_join( + self.url.format(scenario_name), **queries), customs) diff --git a/testapi/testapi-client/testapiclient/client/testcases.py b/testapi/testapi-client/testapiclient/client/testcases.py new file mode 100644 index 0000000..bb2b6d3 --- /dev/null +++ b/testapi/testapi-client/testapiclient/client/testcases.py @@ -0,0 +1,36 @@ +import json + +from testapiclient.client import base +from testapiclient.utils import urlparse + + +class TestcasesClient(base.Client): + resource = 'projects/{}/cases' + + def __init__(self, **kwargs): + super(TestcasesClient, self).__init__(**kwargs) + + def create(self, project_name, testcase_req): + return self.clientmanager.post( + self.url.format(project_name), testcase_req) + + def get(self, project_name): + return json.dumps( + self.clientmanager.get( + self.url.format(project_name))['testcases']) + + def get_one(self, project_name, name): + return json.dumps( + self.clientmanager.get( + urlparse.path_join( + self.url.format(project_name), name))) + + def delete(self, project_name, name): + return self.clientmanager.delete( + urlparse.path_join( + self.url.format(project_name), name)) + + def update(self, project_name, name, testcase_req): + return self.clientmanager.put( + urlparse.path_join( + self.url.format(project_name), name), testcase_req) diff --git a/testapi/testapi-client/testapiclient/models/__init__.py b/testapi/testapi-client/testapiclient/models/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/__init__.py diff --git a/testapi/testapi-client/testapiclient/models/deployresult.py b/testapi/testapi-client/testapiclient/models/deployresult.py new file mode 100644 index 0000000..5c13966 --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/deployresult.py @@ -0,0 +1,17 @@ +class DeployResultCreateRequest(): + def __init__( + self, build_id='', scenario='', stop_date='', start_date='', + upstream_job_name='', version='', pod_name='', criteria='', + installer='', upstream_build_id='', job_name='', details=''): + self.build_id = build_id + self.scenario = scenario + self.stop_date = stop_date + self.start_date = start_date + self.upstream_job_name = upstream_job_name + self.version = version + self.pod_name = pod_name + self.criteria = criteria + self.installer = installer + self.upstream_build_id = upstream_build_id + self.job_name = job_name + self.details = details diff --git a/testapi/testapi-client/testapiclient/models/pods.py b/testapi/testapi-client/testapiclient/models/pods.py new file mode 100644 index 0000000..4fa42e7 --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/pods.py @@ -0,0 +1,6 @@ +class PodCreateRequest(object): + def __init__(self, name='', mode='', details='', role=''): + self.name = name + self.mode = mode + self.details = details + self.role = role diff --git a/testapi/testapi-client/testapiclient/models/project.py b/testapi/testapi-client/testapiclient/models/project.py new file mode 100644 index 0000000..fc85588 --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/project.py @@ -0,0 +1,4 @@ +class ProjectCreateRequest(): + def __init__(self, name='', description=''): + self.description = description + self.name = name diff --git a/testapi/testapi-client/testapiclient/models/result.py b/testapi/testapi-client/testapiclient/models/result.py new file mode 100644 index 0000000..766c03a --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/result.py @@ -0,0 +1,16 @@ +class ResultCreateRequest(): + def __init__( + self, project_name='', scenario='', case_name='', pod_name='', + installer='', version='', stop_date='', build_tag='', criteria='', + start_date='', details=''): + self.project_name = project_name + self.scenario = scenario + self.case_name = case_name + self.pod_name = pod_name + self.installer = installer + self.version = version + self.stop_date = stop_date + self.build_tag = build_tag + self.criteria = criteria + self.start_date = start_date + self.details = details diff --git a/testapi/testapi-client/testapiclient/models/scenario.py b/testapi/testapi-client/testapiclient/models/scenario.py new file mode 100644 index 0000000..f4f0f40 --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/scenario.py @@ -0,0 +1,37 @@ +class ScenarioCreateRequest: + def __init__(self, name='', installers=[]): + self.name = name + self.installers = installers + + +class ScenarioInstallerCreateRequest: + def __init__(self, installer='', versions=[]): + self.installer = installer + self.versions = versions + + +class ScenarioVersionCreateRequest: + def __init__(self, version='', owner='', projects=[]): + self.version = version + self.owner = owner + self.projects = projects + + +class ScenarioProjectCreateRequest: + def __init__(self, project='', scores=[], trust_indicators=[], customs=[]): + self.project = project + self.scores = scores + self.trust_indicators = trust_indicators + self.customs = customs + + +class ScenarioScoreCreateRequest: + def __init__(self, score='', date=''): + self.score = score + self.date = date + + +class ScenarioTICreateRequest: + def __init__(self, status='', date=''): + self.status = status + self.date = date diff --git a/testapi/testapi-client/testapiclient/models/testcase.py b/testapi/testapi-client/testapiclient/models/testcase.py new file mode 100644 index 0000000..70d5d78 --- /dev/null +++ b/testapi/testapi-client/testapiclient/models/testcase.py @@ -0,0 +1,20 @@ +class TestCaseCreateRequest(): + def __init__( + self, run='', name='', ci_loop='', tags='', url='', + blocking='', domains='', dependencies='', version='', + criteria='', tier='', trust='', catalog_description='', + description=''): + self.run = run + self.name = name + self.ci_loop = ci_loop + self.tags = tags + self.url = url + self.blocking = blocking + self.domains = domains + self.dependencies = dependencies + self.version = version + self.criteria = criteria + self.tier = tier + self.trust = trust + self.catalog_description = catalog_description + self.description = description diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_app.py b/testapi/testapi-client/testapiclient/tests/unit/test_app.py new file mode 100644 index 0000000..c20b27f --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_app.py @@ -0,0 +1,50 @@ +import urllib + +from mock import mock + +from testapiclient import main +from testapiclient.tests.unit import utils +from testapiclient.tests.unit import fakes + + +class MainTest(utils.TestCommand): + def setUp(self): + super(MainTest, self).setUp() + self.app = main.TestAPIClient() + self.cas_sever = '{}{}{}'.format( + self.env_variables['testapi_cas_auth_url'], + urllib.quote(self.env_variables['testapi_url']), + self.env_variables['testapi_cas_signin_return']) + self.headers = { + 'Content-type': 'application/json', + 'Accept': 'text/plain'} + + def test_auth_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data={'text': "success"}) + self.app.run( + ['-u', 'user', '-p', 'pass', 'pod', 'create', + '{"name": "asfad"}']) + self.post_mock.assert_called_with( + 'http://localhost:8000/api/v1/pods', + data='{"name": "asfad"}', + headers=self.headers) + + def test_auth_failure(self): + self.post_mock.return_value = fakes.FakeResponse( + data={'text': "login"}) + self.app.run( + ['-u', 'user', '-p', 'pass', 'pod', 'create', + '{"name": "asfad"}']) + self.post_mock.assert_called_once_with( + self.cas_sever, + {'pass': 'pass', 'name': 'user', 'form_id': 'user_login'} + ) + + def test_auth_not_called(self): + self.auth_post = mock.patch( + 'testapiclient.utils.clientmanager.ClientManager.auth').start() + self.app.run(['pod', 'get']) + self.auth_post.assert_not_called() + self.get_mock.assert_called_once_with( + 'http://localhost:8000/api/v1/pods', headers=self.headers) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_deployresults.py b/testapi/testapi-client/testapiclient/tests/unit/test_deployresults.py new file mode 100644 index 0000000..0e0385b --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_deployresults.py @@ -0,0 +1,109 @@ +import json + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.cli import deployresults +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class DeployresultTest(utils.TestCommand): + def setUp(self): + super(DeployresultTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'deployresults') + self.deployresult_json = { + 'job_name': 'daisy-deploy', + 'scenario': 'test-scenario', + 'stop_date': '2018-04-09 13:44:53', + 'upstream_job_name': 'test-job', + 'build_id': 'test-build', + 'version': 'test-version', + 'pod_name': 'test-pod', + 'criteria': 'test-criteria', + 'installer': 'test-installer', + 'start_date': '2018-04-09 13:44:53', + 'details': 'test-details', + 'upstream_build_id': 'test-stream' + } + self.deployresult_string = json.dumps(self.deployresult_json) + + +class DeployresultGetTest(DeployresultTest): + + def setUp(self): + super(DeployresultGetTest, self).setUp() + self.deployresults_rsp = {'deployresults': [self.deployresult_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.deployresults_rsp) + deployresult_get = deployresults.DeployresultGet( + self.app, mock.Mock()) + args = ['-job-name', 'dfs'] + verifies = [('job_name', 'dfs')] + parsed_args = self.check_parser(deployresult_get, args, verifies) + deployresult_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '?job_name=dfs', + headers=clientmanager.ClientManager.headers) + + def test_get_all(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.deployresults_rsp) + deployresult_get = deployresults.DeployresultGet( + self.app, mock.Mock()) + args = [] + verifies = [] + parsed_args = self.check_parser(deployresult_get, args, verifies) + deployresult_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.deployresult_json) + deployresult_get_one = deployresults.DeployresultGetOne( + self.app, mock.Mock()) + args = ['def'] + verifies = [('deployresult_id', 'def')] + parsed_args = self.check_parser( + deployresult_get_one, args, verifies) + deployresult_get_one.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class DeployresultCreateTest(DeployresultTest): + + def setUp(self): + super(DeployresultCreateTest, self).setUp() + + def test_create_success(self): + succ_rsp = { + 'href': '{}/{}'.format(self.base_url, + self.deployresult_json.get('project_name')) + } + self.post_mock.return_value = fakes.FakeResponse(data=succ_rsp) + deployresult_create = deployresults.DeployresultCreate( + self.app, mock.Mock()) + args = [self.deployresult_string] + verifies = [('deployresult', self.deployresult_json)] + parsed_args = self.check_parser(deployresult_create, args, verifies) + deployresult_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + deployresult_create = deployresults.DeployresultCreate( + self.app, mock.Mock()) + args = [self.deployresult_string] + verifies = [('deployresult', self.deployresult_json)] + parsed_args = self.check_parser( + deployresult_create, args, verifies) + deployresult_create.take_action(parsed_args) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_deployresults_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_deployresults_client.py new file mode 100644 index 0000000..03288fe --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_deployresults_client.py @@ -0,0 +1,81 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import deploy_results +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class DeployResultsClientTest(utils.TestCommand): + def setUp(self): + super(DeployResultsClientTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'deployresults') + self.deployresult_json = { + 'project_name': 'functest', + 'scenario': 'test-scenario', + 'stop_date': '2018-04-09 13:44:53', + 'case_name': 'test-case', + 'build_tag': 'test-build', + 'version': 'test-version', + 'pod_name': 'test-pod', + 'criteria': 'test-criteria', + 'installer': 'test-installer', + 'start_date': '2018-04-09 13:44:53', + 'details': 'test-details' + } + self.deployresult_id = '5a6dc1089a07c80f3c9f8d62' + self.deployresult_string = json.dumps(self.deployresult_json) + self.deployresult_client = deploy_results.DeployResultsClient() + + +class DeployResultsClientGetTest(DeployResultsClientTest): + + def setUp(self): + super(DeployResultsClientGetTest, self).setUp() + self.deployresults_rsp = {'deployresults': [self.deployresult_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.deployresults_rsp) + self.deployresult_client.get() + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_search(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.deployresults_rsp) + self.deployresult_client.get(name='deployresult1') + self.get_mock.assert_called_once_with( + self.base_url + '?name=deployresult1', + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.deployresult_json) + self.deployresult_client.get_one('2333') + self.get_mock.assert_called_once_with( + self.base_url + '/2333', + headers=clientmanager.ClientManager.headers) + + +class DeployResultsClientCreateTest(DeployResultsClientTest): + + def setUp(self): + super(DeployResultsClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format(self.base_url, self.deployresult_id) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=self.succ_rsp) + self.deployresult_client.create(self.deployresult_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.deployresult_client.create(self.deployresult_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_placeholder.py b/testapi/testapi-client/testapiclient/tests/unit/test_placeholder.py deleted file mode 100644 index 2b7ad46..0000000 --- a/testapi/testapi-client/testapiclient/tests/unit/test_placeholder.py +++ /dev/null @@ -1,6 +0,0 @@ -import testtools - - -class TestPlaceHolder(testtools.TestCase): - def test_placeholder(self): - self.assertEqual(1, 1) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_pod_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_pod_client.py new file mode 100644 index 0000000..1df5660 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_pod_client.py @@ -0,0 +1,89 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import pods +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class PodClientTest(utils.TestCommand): + def setUp(self): + super(PodClientTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'pods') + self.pod_json = { + 'role': 'community-ci', + 'name': 'test_pod', + 'details': '', + 'mode': 'metal' + } + self.pod_client = pods.PodsClient() + self.pod_string = json.dumps(self.pod_json) + + +class PodClientGetTest(PodClientTest): + + def setUp(self): + super(PodClientGetTest, self).setUp() + self.pods_rsp = {'pods': [self.pod_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.pods_rsp) + self.pod_client.get() + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_search(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.pods_rsp) + self.pod_client.get(name='pod1') + self.get_mock.assert_called_once_with( + self.base_url + '?name=pod1', + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.pod_json) + self.pod_client.get_one('def') + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class PodClientCreateTest(PodClientTest): + + def setUp(self): + super(PodClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format(self.base_url, self.pod_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=self.succ_rsp) + self.pod_client.create(self.pod_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.pod_client.create(self.pod_json) + + +class PodClientDeleteTest(PodClientTest): + + def setUp(self): + super(PodClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.pod_client.delete('def') + self.delete_mock.assert_called_once_with( + self.base_url + '/def', + data=None, + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.pod_client.delete('def') diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_project_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_project_client.py new file mode 100644 index 0000000..7aa11e6 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_project_client.py @@ -0,0 +1,111 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import projects +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class ProjectClientTest(utils.TestCommand): + def setUp(self): + super(ProjectClientTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'projects') + self.project_json = { + 'description': 'test_description', + 'name': 'test_project', + } + self.project_client = projects.ProjectsClient() + self.project_string = json.dumps(self.project_json) + + +class ProjectClientGetTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientGetTest, self).setUp() + self.projects_rsp = {'projects': [self.project_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.projects_rsp) + self.project_client.get() + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_search(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.projects_rsp) + self.project_client.get(name='project1') + self.get_mock.assert_called_once_with( + self.base_url + '?name=project1', + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.project_json) + self.project_client.get_one('def') + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class ProjectClientCreateTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.project_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.project_client.create(self.project_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.project_client.create(self.project_json) + + +class ProjectClientDeleteTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.project_client.delete('def') + self.delete_mock.assert_called_once_with( + self.base_url + '/def', + data=None, + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.project_client.delete('def') + + +class ProjectClientUpdateTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.project_client.update('def', self.project_json) + self.put_mock.assert_called_once_with( + self.base_url + '/def', + data=self.project_string, + headers=clientmanager.ClientManager.headers) + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.project_client.update('def', self.project_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_results.py b/testapi/testapi-client/testapiclient/tests/unit/test_results.py new file mode 100644 index 0000000..83bcc9f --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_results.py @@ -0,0 +1,98 @@ +import json + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.cli import results +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class ResultTest(utils.TestCommand): + def setUp(self): + super(ResultTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'results') + self.result_json = { + 'project_name': 'functest', + 'scenario': 'test-scenario', + 'stop_date': '2018-04-09 13:44:53', + 'case_name': 'test-case', + 'build_tag': 'test-build', + 'version': 'test-version', + 'pod_name': 'test-pod', + 'criteria': 'test-criteria', + 'installer': 'test-installer', + 'start_date': '2018-04-09 13:44:53', + 'details': 'test-details' + } + self.result_string = json.dumps(self.result_json) + + +class ResultGetTest(ResultTest): + + def setUp(self): + super(ResultGetTest, self).setUp() + self.results_rsp = {'results': [self.result_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.results_rsp) + result_get = results.ResultGet(self.app, mock.Mock()) + args = ['-case', 'dfs'] + verifies = [('case', 'dfs')] + parsed_args = self.check_parser(result_get, args, verifies) + result_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '?case=dfs', + headers=clientmanager.ClientManager.headers) + + def test_get_all(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.results_rsp) + result_get = results.ResultGet(self.app, mock.Mock()) + args = [] + verifies = [] + parsed_args = self.check_parser(result_get, args, verifies) + result_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.result_json) + result_get_one = results.ResultGetOne(self.app, mock.Mock()) + args = ['def'] + verifies = [('result_id', 'def')] + parsed_args = self.check_parser(result_get_one, args, verifies) + result_get_one.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class ResultCreateTest(ResultTest): + + def setUp(self): + super(ResultCreateTest, self).setUp() + + def test_create_success(self): + succ_rsp = { + 'href': '{}/{}'.format(self.base_url, + self.result_json.get('project_name')) + } + self.post_mock.return_value = fakes.FakeResponse(data=succ_rsp) + result_create = results.ResultCreate(self.app, mock.Mock()) + args = [self.result_string] + verifies = [('result', self.result_json)] + parsed_args = self.check_parser(result_create, args, verifies) + result_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + result_create = results.ResultCreate(self.app, mock.Mock()) + args = [self.result_string] + verifies = [('result', self.result_json)] + parsed_args = self.check_parser(result_create, args, verifies) + result_create.take_action(parsed_args) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_results_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_results_client.py new file mode 100644 index 0000000..ae677f7 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_results_client.py @@ -0,0 +1,78 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import results +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class ResultClientTest(utils.TestCommand): + def setUp(self): + super(ResultClientTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'results') + self.result_json = { + 'project_name': 'functest', + 'scenario': 'test-scenario', + 'stop_date': '2018-04-09 13:44:53', + 'case_name': 'test-case', + 'build_tag': 'test-build', + 'version': 'test-version', + 'pod_name': 'test-pod', + 'criteria': 'test-criteria', + 'installer': 'test-installer', + 'start_date': '2018-04-09 13:44:53', + 'details': 'test-details' + } + self.result_id = '5a6dc1089a07c80f3c9f8d62' + self.result_string = json.dumps(self.result_json) + self.result_client = results.ResultsClient() + + +class ResultClientGetTest(ResultClientTest): + + def setUp(self): + super(ResultClientGetTest, self).setUp() + self.results_rsp = {'results': [self.result_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.results_rsp) + self.result_client.get() + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_search(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.results_rsp) + self.result_client.get(name='result1') + self.get_mock.assert_called_once_with( + self.base_url + '?name=result1', + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.result_json) + self.result_client.get_one('2333') + self.get_mock.assert_called_once_with( + self.base_url + '/2333', + headers=clientmanager.ClientManager.headers) + + +class ResultClientCreateTest(ResultClientTest): + + def setUp(self): + super(ResultClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format(self.base_url, self.result_id) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=self.succ_rsp) + self.result_client.create(self.result_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.result_client.create(self.result_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario.py new file mode 100644 index 0000000..b14cf04 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario.py @@ -0,0 +1,147 @@ +import json + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes as fk +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class ScenarioTest(utils.TestCommand): + def setUp(self): + super(ScenarioTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios') + self.scenario_json = { + "installers": [], + "name": "test_scenario" + } + self.scenario_string = json.dumps(self.scenario_json) + + +class ScenarioGetTest(ScenarioTest): + + def setUp(self): + super(ScenarioGetTest, self).setUp() + self.scenarios_rsp = {'scenarios': [self.scenario_json]} + + def test_get(self): + self.get_mock.return_value = fk.FakeResponse(data=self.scenarios_rsp) + scenario_get = scenarios.ScenarioGet(self.app, mock.Mock()) + args = ['-name', 's1', '-installer', + 'i1', '---version', 'v1', '-project', 'p1'] + verifies = [ + ('name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', 'p1')] + parsed_args = self.check_parser(scenario_get, args, verifies) + scenario_get.take_action(parsed_args) + kall = self.get_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + '?version=v1&name=s1&installer=i1&project=p1') + + def test_get_all(self): + self.get_mock.return_value = fk.FakeResponse(data=self.scenarios_rsp) + scenario_get = scenarios.ScenarioGet(self.app, mock.Mock()) + args = [] + verifies = [] + parsed_args = self.check_parser(scenario_get, args, verifies) + scenario_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fk.FakeResponse(data=self.scenario_json) + scenario_get_one = scenarios.ScenarioGetOne(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(scenario_get_one, args, verifies) + scenario_get_one.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class ScenarioCreateTest(ScenarioTest): + + def setUp(self): + super(ScenarioCreateTest, self).setUp() + + def test_create_success(self): + succ_rsp = { + 'href': '{}/{}'.format(self.base_url, + self.scenario_json.get('name')) + } + self.post_mock.return_value = fk.FakeResponse(data=succ_rsp) + scenario_create = scenarios.ScenarioCreate(self.app, mock.Mock()) + args = [self.scenario_string] + verifies = [('scenario', self.scenario_json)] + parsed_args = self.check_parser(scenario_create, args, verifies) + scenario_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + scenario_create = scenarios.ScenarioCreate(self.app, mock.Mock()) + args = [self.scenario_string] + verifies = [('scenario', self.scenario_json)] + parsed_args = self.check_parser(scenario_create, args, verifies) + scenario_create.take_action(parsed_args) + + +class ScenarioDeleteTest(ScenarioTest): + + def setUp(self): + super(ScenarioDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fk.FakeResponse() + scenario_delete = scenarios.ScenarioDelete(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(scenario_delete, args, verifies) + scenario_delete.take_action(parsed_args) + self.delete_mock.assert_called_once_with( + self.base_url + '/def', + data=None, + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + scenario_delete = scenarios.ScenarioDelete(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(scenario_delete, args, verifies) + scenario_delete.take_action(parsed_args) + + +class ScenarioPutTest(ScenarioTest): + + def setUp(self): + super(ScenarioPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fk.FakeResponse(data=self.scenario_json) + scenario_put = scenarios.ScenarioPut(self.app, mock.Mock()) + args = ['def', self.scenario_string] + verifies = [('name', 'def'), ('scenario', self.scenario_json)] + parsed_args = self.check_parser(scenario_put, args, verifies) + scenario_put.take_action(parsed_args) + self.put_mock.assert_called_once() + + def test_put_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + scenario_put = scenarios.ScenarioPut(self.app, mock.Mock()) + args = ['def', self.scenario_string] + verifies = [('name', 'def'), ('scenario', self.scenario_json)] + parsed_args = self.check_parser(scenario_put, args, verifies) + scenario_put.take_action(parsed_args) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_client.py new file mode 100644 index 0000000..6e9e0fa --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_client.py @@ -0,0 +1,104 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class ScenarioClientTest(utils.TestCommand): + def setUp(self): + super(ScenarioClientTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios') + self.scenario_json = { + "installers": [], + "name": "test_scenario" + } + self.scenario_client = scenarios.ScenariosClient() + self.scenario_string = json.dumps(self.scenario_json) + + +class ScenarioClientGetTest(ScenarioClientTest): + + def setUp(self): + super(ScenarioClientGetTest, self).setUp() + self.scenarios_rsp = {'scenarios': [self.scenario_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.scenarios_rsp) + self.scenario_client.get() + self.get_mock.assert_called_once_with( + self.base_url, + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.scenario_json) + self.scenario_client.get_one('def') + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class ScenarioClientCreateTest(ScenarioClientTest): + + def setUp(self): + super(ScenarioClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.scenario_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.scenario_client.create(self.scenario_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.scenario_client.create(self.scenario_json) + + +class ScenarioClientDeleteTest(ScenarioClientTest): + + def setUp(self): + super(ScenarioClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.scenario_client.delete('def') + self.delete_mock.assert_called_once_with( + self.base_url + '/def', + data=None, + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.scenario_client.delete('def') + + +class ScenarioClientUpdateTest(ScenarioClientTest): + + def setUp(self): + super(ScenarioClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.scenario_client.update( + 'def', self.scenario_json) + self.put_mock.assert_called_once_with( + self.base_url + '/def', + data=self.scenario_string, + headers=clientmanager.ClientManager.headers) + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.scenario_client.update('def', self.scenario_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_custom.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_custom.py new file mode 100644 index 0000000..e3f89c0 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_custom.py @@ -0,0 +1,88 @@ + + +from mock import mock +from six.moves.urllib import parse + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class CustomTest(utils.TestCommand): + def setUp(self): + super(CustomTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios/{}/customs') + self.scenario_name = 's1' + self.custom_input = 'custom' + self.custom_parsed = ['custom'] + + +class CustomCreateTest(CustomTest): + + def setUp(self): + super(CustomCreateTest, self).setUp() + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=None) + custom_create = scenarios.CustomCreate(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', + 'v1', '--project', 'p1', self.custom_input] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', 'p1'), + ('custom', self.custom_parsed)] + parsed_args = self.check_parser(custom_create, args, verifies) + custom_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + +class CustomDeleteTest(CustomTest): + + def setUp(self): + super(CustomDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse(data=None) + custom_delete = scenarios.CustomDelete(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', + '--version', 'v1', '--project', 'p1', 'def'] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', 'p1'), + ('name', ['def'])] + parsed_args = self.check_parser(custom_delete, args, verifies) + custom_delete.take_action(parsed_args) + kall = self.delete_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + '?version=v1&project=p1&installer=i1') + + +class CustomPutTest(CustomTest): + + def setUp(self): + super(CustomPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse( + data=None) + custom_put = scenarios.CustomPut(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', 'v1', + '--project', 'p1', self.custom_input] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', 'p1'), + ('custom', self.custom_parsed)] + parsed_args = self.check_parser(custom_put, args, verifies) + custom_put.take_action(parsed_args) + self.put_mock.assert_called_once() diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_custom_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_custom_client.py new file mode 100644 index 0000000..7c6d62c --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_custom_client.py @@ -0,0 +1,106 @@ +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class CustomClientTest(utils.TestCommand): + def setUp(self): + super(CustomClientTest, self).setUp() + self.scenario_name = 'scenrio1' + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/customs'.format(self.scenario_name)) + self.custom_raw = 'custom' + self.custom_input = ['custom'] + self.installer_name = 'installer' + self.version_name = 'version' + self.project_name = 'project' + self.custom_client = scenarios.CustomsClient() + + +class CustomClientCreateTest(CustomClientTest): + + def setUp(self): + super(CustomClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.scenario_name) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.custom_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.custom_raw) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.custom_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.custom_raw) + + +class CustomClientDeleteTest(CustomClientTest): + + def setUp(self): + super(CustomClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.custom_client.delete( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.custom_raw) + kall = self.delete_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + + '?installer=installer&version=version&project=project') + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.custom_client.delete( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.custom_raw) + + +class CustomClientUpdateTest(CustomClientTest): + + def setUp(self): + super(CustomClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.custom_client.update( + self.scenario_name, + self.installer_name, + self.version_name, + self.project_name, + self.custom_raw) + kall = self.put_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + + '?installer=installer&version=version&project=project') + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.custom_client.update( + self.scenario_name, + self.installer_name, + self.version_name, + self.project_name, + self.custom_raw) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_installer.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_installer.py new file mode 100644 index 0000000..2246a59 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_installer.py @@ -0,0 +1,74 @@ +import json + +from mock import mock +from six.moves.urllib import parse + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class InstallerTest(utils.TestCommand): + def setUp(self): + super(InstallerTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios/{}/installers') + self.scenario_name = 's1' + self.installer_json = { + 'versions': [], + 'installer': 'test-installer', + } + self.installer_string = json.dumps(self.installer_json) + + +class InstallerCreateTest(InstallerTest): + + def setUp(self): + super(InstallerCreateTest, self).setUp() + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=None) + installer_create = scenarios.InstallerCreate(self.app, mock.Mock()) + args = ['--scenario-name', 's1', self.installer_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', self.installer_json)] + parsed_args = self.check_parser(installer_create, args, verifies) + installer_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + +class InstallerDeleteTest(InstallerTest): + + def setUp(self): + super(InstallerDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse(data=None) + installer_delete = scenarios.InstallerDelete(self.app, mock.Mock()) + args = ['--scenario-name', 's1', 'def'] + verifies = [('scenario_name', 's1'), ('name', ['def'])] + parsed_args = self.check_parser(installer_delete, args, verifies) + installer_delete.take_action(parsed_args) + self.delete_mock.assert_called_once_with( + self.base_url.format(parsed_args.scenario_name), + data=json.dumps(['def']), + headers=clientmanager.ClientManager.headers) + + +class InstallerPutTest(InstallerTest): + + def setUp(self): + super(InstallerPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse( + data=None) + installer_put = scenarios.InstallerPut(self.app, mock.Mock()) + args = ['--scenario-name', 's1', self.installer_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', self.installer_json)] + parsed_args = self.check_parser(installer_put, args, verifies) + installer_put.take_action(parsed_args) + self.put_mock.assert_called_once() diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_installer_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_installer_client.py new file mode 100644 index 0000000..71ba150 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_installer_client.py @@ -0,0 +1,86 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class InstallerClientTest(utils.TestCommand): + def setUp(self): + super(InstallerClientTest, self).setUp() + self.scenario_name = 'scenrio1' + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/installers'.format(self.scenario_name)) + self.installer_json = { + 'versions': [], + 'installer': 'test-installer', + } + self.installer_client = scenarios.InstallersClient() + self.installer_string = json.dumps(self.installer_json) + + +class InstallerClientCreateTest(InstallerClientTest): + + def setUp(self): + super(InstallerClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.installer_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.installer_client.create(self.scenario_name, self.installer_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.installer_client.create( + self.scenario_name, self.installer_json) + + +class InstallerClientDeleteTest(InstallerClientTest): + + def setUp(self): + super(InstallerClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.installer_client.delete(self.scenario_name, 'def') + self.delete_mock.assert_called_once_with( + self.base_url, + data=json.dumps(['def']), + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.installer_client.delete(self.scenario_name, 'def') + + +class InstallerClientUpdateTest(InstallerClientTest): + + def setUp(self): + super(InstallerClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.installer_client.update( + self.scenario_name, + self.installer_json) + self.put_mock.assert_called_once_with( + self.base_url, + data=self.installer_string, + headers=clientmanager.ClientManager.headers) + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.installer_client.update('def', self.installer_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_project.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_project.py new file mode 100644 index 0000000..7bd6645 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_project.py @@ -0,0 +1,90 @@ +import json + +from mock import mock +from six.moves.urllib import parse + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class ProjectTest(utils.TestCommand): + def setUp(self): + super(ProjectTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios/{}/projects') + self.scenario_name = 's1' + self.project_json = { + 'trust_indicators': [], + 'project': 'test-project', + 'scores': [], + 'customs': [] + } + self.project_string = json.dumps(self.project_json) + + +class ProjectCreateTest(ProjectTest): + + def setUp(self): + super(ProjectCreateTest, self).setUp() + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=None) + project_create = scenarios.ProjectCreate(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', 'v1', + self.project_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', self.project_json)] + parsed_args = self.check_parser(project_create, args, verifies) + project_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + +class ProjectDeleteTest(ProjectTest): + + def setUp(self): + super(ProjectDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse(data=None) + project_delete = scenarios.ProjectDelete(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', 'v1', + 'def'] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('name', ['def'])] + parsed_args = self.check_parser(project_delete, args, verifies) + project_delete.take_action(parsed_args) + kall = self.delete_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + '?version=v1&installer=i1') + + +class ProjectPutTest(ProjectTest): + + def setUp(self): + super(ProjectPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse( + data=None) + project_put = scenarios.ProjectPut(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', 'v1', + self.project_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', self.project_json)] + parsed_args = self.check_parser(project_put, args, verifies) + project_put.take_action(parsed_args) + self.put_mock.assert_called_once() diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_project_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_project_client.py new file mode 100644 index 0000000..f8c3d60 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_project_client.py @@ -0,0 +1,104 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class ProjectClientTest(utils.TestCommand): + def setUp(self): + super(ProjectClientTest, self).setUp() + self.scenario_name = 'scenrio1' + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/projects'.format(self.scenario_name)) + self.project_json = { + 'trust_indicators': [], + 'project': 'test-project', + 'scores': [], + 'customs': [] + } + self.installer_name = 'installer' + self.version_name = 'version' + self.project_client = scenarios.ProjectsClient() + self.project_string = json.dumps(self.project_json) + + +class ProjectClientCreateTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.project_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.project_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.project_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_json) + + +class ProjectClientDeleteTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.project_client.delete( + self.scenario_name, self.installer_name, + self.version_name, 'def') + kall = self.delete_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + '?installer=installer&version=version') + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.project_client.delete( + self.scenario_name, self.installer_name, + self.version_name, 'def') + + +class ProjectClientUpdateTest(ProjectClientTest): + + def setUp(self): + super(ProjectClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.project_client.update( + self.scenario_name, + self.installer_name, + self.version_name, + self.project_json) + kall = self.put_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + '?installer=installer&version=version') + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.project_client.update( + self.scenario_name, + self.installer_name, + self.version_name, + self.project_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_score.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_score.py new file mode 100644 index 0000000..3b0e1c6 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_score.py @@ -0,0 +1,42 @@ +import json + +from mock import mock +from six.moves.urllib import parse + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class ScoreTest(utils.TestCommand): + def setUp(self): + super(ScoreTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios/{}/scores') + self.scenario_name = 's1' + self.score_json = { + 'score': 'test_score1', + 'date': '2018/01/2' + } + self.score_string = json.dumps(self.score_json) + + +class ScoreCreateTest(ScoreTest): + + def setUp(self): + super(ScoreCreateTest, self).setUp() + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=None) + score_create = scenarios.ScoreCreate(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', 'v1', + '--project', 'p1', self.score_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', 'p1'), + ('score', self.score_json)] + parsed_args = self.check_parser(score_create, args, verifies) + score_create.take_action(parsed_args) + self.post_mock.assert_called_once() diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_score_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_score_client.py new file mode 100644 index 0000000..beebd47 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_score_client.py @@ -0,0 +1,53 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class ScoreClientTest(utils.TestCommand): + def setUp(self): + super(ScoreClientTest, self).setUp() + self.scenario_name = 'scenrio1' + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/scores'.format(self.scenario_name)) + self.score_json = { + 'score': 'test_score1', + 'date': '2018/01/2' + } + self.installer_name = 'installer' + self.version_name = 'version' + self.project_name = 'project' + self.score_client = scenarios.ScoresClient() + self.score_string = json.dumps(self.score_json) + + +class ScoreClientCreateTest(ScoreClientTest): + + def setUp(self): + super(ScoreClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.score_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.score_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.score_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.score_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.score_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_trust_indicator.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_trust_indicator.py new file mode 100644 index 0000000..04be30c --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_trust_indicator.py @@ -0,0 +1,45 @@ +import json + +from mock import mock +from six.moves.urllib import parse + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class TrustIndicatorTest(utils.TestCommand): + def setUp(self): + super(TrustIndicatorTest, self).setUp() + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/trustindicators' + ) + self.scenario_name = 's1' + self.trust_indicator_json = { + 'status': 'test_status', + 'date': '2018/01/2' + } + self.trust_indicator_string = json.dumps(self.trust_indicator_json) + + +class TrustIndicatorCreateTest(TrustIndicatorTest): + + def setUp(self): + super(TrustIndicatorCreateTest, self).setUp() + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=None) + ti_create = scenarios.TrustIndicatorCreate(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', '--version', 'v1', + '--project', 'p1', self.trust_indicator_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('project', 'p1'), + ('trust_indicator', self.trust_indicator_json)] + parsed_args = self.check_parser(ti_create, args, verifies) + ti_create.take_action(parsed_args) + self.post_mock.assert_called_once() diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_trust_indicator_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_trust_indicator_client.py new file mode 100644 index 0000000..e44e2d2 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_trust_indicator_client.py @@ -0,0 +1,53 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils + + +class TrustIndicatorClientTest(utils.TestCommand): + def setUp(self): + super(TrustIndicatorClientTest, self).setUp() + self.scenario_name = 'scenrio1' + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/trust_indicators'.format(self.scenario_name)) + self.trust_indicator_json = { + 'status': 'test_status', + 'date': '2018/01/2' + } + self.installer_name = 'installer' + self.version_name = 'version' + self.project_name = 'project' + self.trust_indicator_client = scenarios.TrustIndicatorsClient() + self.trust_indicator_string = json.dumps(self.trust_indicator_json) + + +class TrustIndicatorClientCreateTest(TrustIndicatorClientTest): + + def setUp(self): + super(TrustIndicatorClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.trust_indicator_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.trust_indicator_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.trust_indicator_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.trust_indicator_client.create( + self.scenario_name, self.installer_name, + self.version_name, self.project_name, + self.trust_indicator_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_version.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_version.py new file mode 100644 index 0000000..280e9a6 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_version.py @@ -0,0 +1,107 @@ +import json + +from mock import mock +from six.moves.urllib import parse + +from testapiclient.cli import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class VersionTest(utils.TestCommand): + def setUp(self): + super(VersionTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'scenarios/{}/versions') + self.scenario_name = 's1' + self.version_json = { + 'projects': [], + 'version': 'test-version', + 'owner': 'test_owner' + } + self.version_string = json.dumps(self.version_json) + + +class VersionCreateTest(VersionTest): + + def setUp(self): + super(VersionCreateTest, self).setUp() + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse(data=None) + version_create = scenarios.VersionCreate(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', self.version_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', self.version_json)] + parsed_args = self.check_parser(version_create, args, verifies) + version_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + +class VersionDeleteTest(VersionTest): + + def setUp(self): + super(VersionDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse(data=None) + version_delete = scenarios.VersionDelete(self.app, mock.Mock()) + args = ['--scenario-name', 's1', '--installer', 'i1', 'def'] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('name', ['def'])] + parsed_args = self.check_parser(version_delete, args, verifies) + version_delete.take_action(parsed_args) + self.delete_mock.assert_called_once_with( + self.base_url.format(parsed_args.scenario_name) + '?installer=i1', + data=json.dumps(['def']), + headers=clientmanager.ClientManager.headers) + + +class VersionPutTest(VersionTest): + + def setUp(self): + super(VersionPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse( + data=None) + version_put = scenarios.VersionPut(self.app, mock.Mock()) + args = [ + '--scenario-name', 's1', '--installer', 'i1', self.version_string] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', self.version_json)] + parsed_args = self.check_parser(version_put, args, verifies) + version_put.take_action(parsed_args) + self.put_mock.assert_called_once() + + +class VersionOwnerPutTest(VersionTest): + + def setUp(self): + super(VersionOwnerPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse( + data=None) + version_put = scenarios.VersionOwnerPut(self.app, mock.Mock()) + version_owner = { + 'owner': 'test_owner' + } + args = [ + '--scenario-name', 's1', '--installer', 'i1', + '--version', 'v1', json.dumps(version_owner)] + verifies = [ + ('scenario_name', 's1'), + ('installer', 'i1'), + ('version', 'v1'), + ('owner', version_owner)] + parsed_args = self.check_parser(version_put, args, verifies) + version_put.take_action(parsed_args) + self.put_mock.assert_called_once() diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_scenario_version_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_version_client.py new file mode 100644 index 0000000..1ae2409 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_scenario_version_client.py @@ -0,0 +1,96 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import scenarios +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class VersionClientTest(utils.TestCommand): + def setUp(self): + super(VersionClientTest, self).setUp() + self.scenario_name = 'scenrio1' + self.base_url = parse.urljoin( + self.api_url, + 'scenarios/{}/versions'.format(self.scenario_name)) + self.version_json = { + 'projects': [], + 'version': 'test-version', + 'owner': 'test_owner' + } + self.installer_name = 'installer' + self.version_client = scenarios.VersionsClient() + self.version_string = json.dumps(self.version_json) + + +class VersionClientCreateTest(VersionClientTest): + + def setUp(self): + super(VersionClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.version_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.version_client.create( + self.scenario_name, self.installer_name, self.version_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.version_client.create( + self.scenario_name, self.installer_name, self.version_json) + + +class VersionClientDeleteTest(VersionClientTest): + + def setUp(self): + super(VersionClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.version_client.delete( + self.scenario_name, self.installer_name, 'def') + kall = self.delete_mock.call_args + args, kwargs = kall + self.assert_url( + args[0], + self.base_url + '?installer=installer') + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.version_client.delete( + self.scenario_name, self.installer_name, 'def') + + +class VersionClientUpdateTest(VersionClientTest): + + def setUp(self): + super(VersionClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.version_client.update( + self.scenario_name, + self.installer_name, + self.version_json) + self.put_mock.assert_called_once_with( + self.base_url + '?installer=installer', + data=self.version_string, + headers=clientmanager.ClientManager.headers) + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.version_client.update( + self.scenario_name, + self.installer_name, + self.version_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_testcase_client.py b/testapi/testapi-client/testapiclient/tests/unit/test_testcase_client.py new file mode 100644 index 0000000..d80ae27 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_testcase_client.py @@ -0,0 +1,118 @@ +import json + +from six.moves.urllib import parse +import testtools + +from testapiclient.client import testcases +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class TestcaseClientTest(utils.TestCommand): + def setUp(self): + super(TestcaseClientTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'projects/{}/cases') + self.project_name = 'functest' + self.testcase_json = { + 'run': '', + 'name': 'test-case', + 'ci_loop': '', + 'tags': '', + 'url': '', + 'blocking': '', + 'domains': '', + 'dependencies': '', + 'version': '', + 'criteria': '', + 'tier': '', + 'trust': '', + 'catalog_description': '', + 'description': '' + } + self.testcase_client = testcases.TestcasesClient() + self.testcase_string = json.dumps(self.testcase_json) + + +class TestcaseClientGetTest(TestcaseClientTest): + + def setUp(self): + super(TestcaseClientGetTest, self).setUp() + self.testcases_rsp = {'testcases': [self.testcase_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.testcases_rsp) + self.testcase_client.get(self.project_name) + self.get_mock.assert_called_once_with( + self.base_url.format(self.project_name), + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.testcase_json) + self.testcase_client.get_one(self.project_name, 'def') + self.get_mock.assert_called_once_with( + self.base_url.format(self.project_name) + '/def', + headers=clientmanager.ClientManager.headers) + + +class TestcaseClientCreateTest(TestcaseClientTest): + + def setUp(self): + super(TestcaseClientCreateTest, self).setUp() + self.succ_rsp = { + 'href': '{}/{}'.format( + self.base_url, self.testcase_json.get('name')) + } + + def test_create_success(self): + self.post_mock.return_value = fakes.FakeResponse( + data=self.succ_rsp) + self.testcase_client.create(self.project_name, self.testcase_json) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + self.testcase_client.create(self.project_name, self.testcase_json) + + +class TestcaseClientDeleteTest(TestcaseClientTest): + + def setUp(self): + super(TestcaseClientDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + self.testcase_client.delete(self.project_name, 'def') + self.delete_mock.assert_called_once_with( + self.base_url.format(self.project_name) + '/def', + data=None, + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + self.testcase_client.delete(self.project_name, 'def') + + +class TestcaseClientUpdateTest(TestcaseClientTest): + + def setUp(self): + super(TestcaseClientUpdateTest, self).setUp() + + def test_update_success(self): + self.put_mock.return_value = fakes.FakeResponse() + self.testcase_client.update( + self.project_name, 'def', self.testcase_json) + self.put_mock.assert_called_once_with( + self.base_url.format(self.project_name) + '/def', + data=self.testcase_string, + headers=clientmanager.ClientManager.headers) + + def test_update_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + self.testcase_client.update( + self.project_name, 'def', self.testcase_json) diff --git a/testapi/testapi-client/testapiclient/tests/unit/test_testcases.py b/testapi/testapi-client/testapiclient/tests/unit/test_testcases.py new file mode 100644 index 0000000..6fd2120 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_testcases.py @@ -0,0 +1,155 @@ +import json + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.cli import testcases +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class TestcaseTest(utils.TestCommand): + def setUp(self): + super(TestcaseTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'projects/{}/cases') + self.project_name = 'functest' + self.testcase_json = { + 'run': '', + 'name': 'test-case', + 'ci_loop': '', + 'tags': '', + 'url': '', + 'blocking': '', + 'domains': '', + 'dependencies': '', + 'version': '', + 'criteria': '', + 'tier': '', + 'trust': '', + 'catalog_description': '', + 'description': '' + } + self.testcase_string = json.dumps(self.testcase_json) + + +class TestcaseGetTest(TestcaseTest): + + def setUp(self): + super(TestcaseGetTest, self).setUp() + self.testcases_rsp = {'testcases': [self.testcase_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.testcases_rsp) + testcase_get = testcases.TestcaseGet(self.app, mock.Mock()) + args = ['--project-name', 'dfs'] + verifies = [('project_name', 'dfs')] + parsed_args = self.check_parser(testcase_get, args, verifies) + testcase_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url.format(parsed_args.project_name), + headers=clientmanager.ClientManager.headers) + + def test_get_one(self): + self.get_mock.return_value = fakes.FakeResponse( + data=self.testcase_json) + testcase_get_one = testcases.TestcaseGetOne(self.app, mock.Mock()) + args = ['--project-name', 'functest', 'def'] + verifies = [('project_name', 'functest'), ('name', 'def')] + parsed_args = self.check_parser(testcase_get_one, args, verifies) + testcase_get_one.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url.format(parsed_args.project_name) + '/def', + headers=clientmanager.ClientManager.headers) + + +class TestcaseCreateTest(TestcaseTest): + + def setUp(self): + super(TestcaseCreateTest, self).setUp() + + def test_create_success(self): + succ_rsp = { + 'href': '{}/{}'.format(self.base_url.format(self.project_name), + self.testcase_json.get('name')) + } + self.post_mock.return_value = fakes.FakeResponse(data=succ_rsp) + testcase_create = testcases.TestcaseCreate(self.app, mock.Mock()) + args = ['--project-name', 'functest', self.testcase_string] + verifies = [ + ('project_name', 'functest'), + ('testcase', self.testcase_json)] + parsed_args = self.check_parser(testcase_create, args, verifies) + testcase_create.take_action(parsed_args) + self.post_mock.assert_called_once() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + testcase_create = testcases.TestcaseCreate(self.app, mock.Mock()) + args = ['--project-name', 'functest', self.testcase_string] + verifies = [ + ('project_name', 'functest'), + ('testcase', self.testcase_json)] + parsed_args = self.check_parser(testcase_create, args, verifies) + testcase_create.take_action(parsed_args) + + +class TestcaseDeleteTest(TestcaseTest): + + def setUp(self): + super(TestcaseDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + testcase_delete = testcases.TestcaseDelete(self.app, mock.Mock()) + args = ['--project-name', 'functest', 'def'] + verifies = [('project_name', 'functest'), ('name', 'def')] + parsed_args = self.check_parser(testcase_delete, args, verifies) + testcase_delete.take_action(parsed_args) + self.delete_mock.assert_called_once_with( + self.base_url.format(parsed_args.project_name) + '/def', + data=None, + headers=clientmanager.ClientManager.headers) + + def test_delete_failure(self): + with testtools.ExpectedException(Exception, 'Delete failed: Error'): + self.delete_mock.return_value = utils.FAKE_FAILURE + testcase_delete = testcases.TestcaseDelete(self.app, mock.Mock()) + args = ['--project-name', 'functest', 'def'] + verifies = [('project_name', 'functest'), ('name', 'def')] + parsed_args = self.check_parser(testcase_delete, args, verifies) + testcase_delete.take_action(parsed_args) + + +class TestcasePutTest(TestcaseTest): + + def setUp(self): + super(TestcasePutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse( + data=self.testcase_json) + testcase_put = testcases.TestcasePut(self.app, mock.Mock()) + args = ['--project-name', 'functest', 'def', self.testcase_string] + verifies = [ + ('project_name', 'functest'), + ('name', 'def'), + ('testcase', self.testcase_json)] + parsed_args = self.check_parser(testcase_put, args, verifies) + testcase_put.take_action(parsed_args) + self.put_mock.assert_called_once() + + def test_put_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + testcase_put = testcases.TestcasePut(self.app, mock.Mock()) + args = ['--project-name', 'functest', 'def', self.testcase_string] + verifies = [ + ('project_name', 'functest'), + ('name', 'def'), + ('testcase', self.testcase_json)] + parsed_args = self.check_parser(testcase_put, args, verifies) + testcase_put.take_action(parsed_args) diff --git a/testapi/testapi-client/testapiclient/tests/unit/utils.py b/testapi/testapi-client/testapiclient/tests/unit/utils.py index 20f9a47..c59aadd 100644 --- a/testapi/testapi-client/testapiclient/tests/unit/utils.py +++ b/testapi/testapi-client/testapiclient/tests/unit/utils.py @@ -1,6 +1,7 @@ import httplib from mock import mock +from six.moves.urllib import parse import testtools from testapiclient.tests.unit import fakes @@ -18,7 +19,7 @@ class TestCommand(testtools.TestCase): def setUp(self): super(TestCommand, self).setUp() - env_variables = { + self.env_variables = { 'testapi_url': 'http://localhost:8000/api/v1', 'testapi_cas_auth_url': ( @@ -28,7 +29,7 @@ class TestCommand(testtools.TestCase): 'testapi_cas_signin_return': '/auth/signin_return' } self.config_mock = mock.patch.dict( - 'os.environ', env_variables).start() + 'os.environ', self.env_variables).start() self.fake_stdout = fakes.FakeStdout() self.fake_log = fakes.FakeLog() self.app = fakes.FakeApp(self.fake_stdout, self.fake_log) @@ -50,3 +51,8 @@ class TestCommand(testtools.TestCase): self.assertIn(attr, parsed_args) self.assertEqual(value, getattr(parsed_args, attr)) return parsed_args + + def assert_url(self, actual_url, expected_url): + actual_parsed = parse.parse_qs(parse.urlparse(actual_url).query) + expected_parsed = parse.parse_qs(parse.urlparse(expected_url).query) + assert actual_parsed == expected_parsed diff --git a/testapi/testapi-client/testapiclient/utils/clientmanager.py b/testapi/testapi-client/testapiclient/utils/clientmanager.py index 4401231..cbfd723 100644 --- a/testapi/testapi-client/testapiclient/utils/clientmanager.py +++ b/testapi/testapi-client/testapiclient/utils/clientmanager.py @@ -10,7 +10,9 @@ LOG = logging.getLogger(__name__) class ClientManager(object): - headers = {'Content-type': 'application/json', 'Accept': 'text/plain'} + headers = { + 'Content-type': 'application/json', + 'Accept': 'text/plain'} def __init__(self, cli_options=None): self.cli_options = cli_options @@ -49,6 +51,8 @@ class ClientManager(object): headers=self.headers)) def post(self, url, data): + if 'results' in url or 'deployresults' in url: + self.headers['X-Auth-Token'] = os.environ.get('testapi_token') return self._parse_response('Create', self._request('post', url, data=json.dumps(data), @@ -75,6 +79,9 @@ class ClientManager(object): def _parse_response(self, op, response): if response.status_code == httplib.OK: - return response.json() if op != 'Delete' else None + if op != 'Delete' and response.text != '': + return response.json() + else: + return None else: self._raise_failure(op, response) diff --git a/testapi/testapi-client/testapiclient/utils/command.py b/testapi/testapi-client/testapiclient/utils/command.py index 9614acf..b9d1ce8 100644 --- a/testapi/testapi-client/testapiclient/utils/command.py +++ b/testapi/testapi-client/testapiclient/utils/command.py @@ -20,17 +20,6 @@ class CommandMeta(abc.ABCMeta): @six.add_metaclass(CommandMeta) class Command(command.Command): - - def get_parser(self, prog_name): - parser = super(Command, self).get_parser(prog_name) - parser.add_argument('-u', - type=str, - help='Username for authentication') - parser.add_argument('-p', - type=str, - help='Password for authentication') - return parser - def run(self, parsed_args): self.log.debug('run(%s)', parsed_args) return super(Command, self).run(parsed_args) diff --git a/testapi/testapi-client/testapiclient/utils/urlparse.py b/testapi/testapi-client/testapiclient/utils/urlparse.py index 9f99a46..47d40d5 100644 --- a/testapi/testapi-client/testapiclient/utils/urlparse.py +++ b/testapi/testapi-client/testapiclient/utils/urlparse.py @@ -17,9 +17,9 @@ def query_join(base, **queries): return base + '?' + parse.urlencode(queries) -def resource_join(url): +def resource_join(*url): testapi_url = os.environ.get('testapi_url') - return path_join(testapi_url, url) + return path_join(testapi_url, *url) def get_queries(queries, parsed_args): |