diff options
Diffstat (limited to 'testapi/testapi-client/testapiclient')
57 files changed, 4262 insertions, 0 deletions
diff --git a/testapi/testapi-client/testapiclient/__init__.py b/testapi/testapi-client/testapiclient/__init__.py new file mode 100644 index 0000000..363bc38 --- /dev/null +++ b/testapi/testapi-client/testapiclient/__init__.py @@ -0,0 +1,8 @@ +############################################################################## +# Copyright (c) 2016 ZTE Corporation +# feng.xiaowei@zte.com.cn +# All rights reserved. This program and the accompanying materials +# are made available under the terms of the Apache License, Version 2.0 +# which accompanies this distribution, and is available at +# http://www.apache.org/licenses/LICENSE-2.0 +############################################################################## diff --git a/testapi/testapi-client/testapiclient/cli/__init__.py b/testapi/testapi-client/testapiclient/cli/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/__init__.py 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 new file mode 100644 index 0000000..a7706f6 --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/pods.py @@ -0,0 +1,89 @@ +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(): + return urlparse.resource_join('pods') + + +def pod_url(parsed_args): + return urlparse.path_join(pods_url(), parsed_args.name) + + +class PodGet(command.Lister): + "Handle get request for pods" + + def get_parser(self, prog_name): + parser = super(PodGet, self).get_parser(prog_name) + parser.add_argument('-name', + default='', + help='Search pods using name') + return parser + + def take_action(self, parsed_args): + columns = ( + "name", + "_id", + "creator", + "role", + "mode", + "creation_date", + ) + + data = self.app.client_manager.get( + urlparse.query_by(pods_url(), 'name', parsed_args)) + return self.format_output(columns, data.get('pods', [])) + + +class PodGetOne(command.ShowOne): + "Handle get request for pod by name" + + def get_parser(self, prog_name): + parser = super(PodGetOne, self).get_parser(prog_name) + parser.add_argument('name', + default='', + help='Find pod using name') + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.get(pod_url(parsed_args))) + + +class PodCreate(command.ShowOne): + "Handle post request for pods" + + def get_parser(self, prog_name): + parser = super(PodCreate, self).get_parser(prog_name) + parser.add_argument('pod', + type=json.loads, + help='Pod create request format :\n' + '\'{}\''.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): + client = pods.PodsClient(client_manager=self.app.client_manager) + return self.format_output(client.create(parsed_args.pod)) + + +class PodDelete(command.Command): + "Handle delete request for pods" + + def get_parser(self, prog_name): + parser = super(PodDelete, self).get_parser(prog_name) + parser.add_argument('name', + type=str, + help='Delete pods using name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete(pod_url(parsed_args)) diff --git a/testapi/testapi-client/testapiclient/cli/projects.py b/testapi/testapi-client/testapiclient/cli/projects.py new file mode 100644 index 0000000..2fa5b5b --- /dev/null +++ b/testapi/testapi-client/testapiclient/cli/projects.py @@ -0,0 +1,97 @@ +import json + +from testapiclient.utils import command +from testapiclient.utils import urlparse +from testapiclient.models import project + + +def projects_url(): + return urlparse.resource_join('projects') + + +def project_url(parsed_args): + return urlparse.path_join(projects_url(), parsed_args.name) + + +class ProjectGet(command.Lister): + + def get_parser(self, prog_name): + parser = super(ProjectGet, self).get_parser(prog_name) + parser.add_argument('-name', + help='Search projects by name') + return parser + + def take_action(self, parsed_args): + columns = ( + 'name', + '_id', + 'creator', + 'creation_date' + ) + data = self.app.client_manager.get( + urlparse.query_by(projects_url(), 'name', parsed_args)) + return self.format_output(columns, data.get('projects', [])) + + +class ProjectGetOne(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ProjectGetOne, self).get_parser(prog_name) + parser.add_argument('name', + help='Search project by name') + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.get(project_url(parsed_args))) + + +class ProjectCreate(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ProjectCreate, self).get_parser(prog_name) + parser.add_argument('project', + type=json.loads, + help='Project create request format :\n' + '\'{}\''.format(json.dumps( + project.ProjectCreateRequest().__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.post(projects_url(), parsed_args.project)) + + +class ProjectDelete(command.Command): + + def get_parser(self, prog_name): + parser = super(ProjectDelete, self).get_parser(prog_name) + parser.add_argument('name', + type=str, + help='Delete project by name') + return parser + + def take_action(self, parsed_args): + return self.app.client_manager.delete(project_url(parsed_args)) + + +class ProjectPut(command.ShowOne): + + def get_parser(self, prog_name): + parser = super(ProjectPut, self).get_parser(prog_name) + parser.add_argument('name', + type=str, + help='Update project by name') + parser.add_argument('project', + type=json.loads, + help='Project Update request format :\n' + '\'{}\''.format(json.dumps( + project.ProjectCreateRequest().__dict__ + ))) + return parser + + def take_action(self, parsed_args): + return self.format_output( + self.app.client_manager.put( + project_url(parsed_args), parsed_args.project)) 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/main.py b/testapi/testapi-client/testapiclient/main.py new file mode 100644 index 0000000..a448146 --- /dev/null +++ b/testapi/testapi-client/testapiclient/main.py @@ -0,0 +1,54 @@ +import sys + +from cliff import app +from cliff import commandmanager + +from testapiclient.utils import clientmanager + + +class TestAPIClient(app.App): + + def __init__(self): + super(TestAPIClient, self).__init__( + description='TestAPI Client', + version='0.1', + command_manager=commandmanager.CommandManager('testapi'), + deferred_help=True, + ) + + def build_option_parser(self, description, version, argparse_kwargs=None): + self.LOG.debug('build_option_parser') + parser = super(TestAPIClient, self).build_option_parser( + description, + version, + argparse_kwargs) + parser.add_argument('-u', + type=str, + help='Username for authentication') + parser.add_argument('-p', + type=str, + help='Password for authentication') + return parser + + def initialize_app(self, argv): + self.LOG.debug('initialize_app') + self.client_manager = clientmanager.ClientManager(self.options) + + def prepare_to_run_command(self, cmd): + self.LOG.debug('prepare_to_run_command %s', cmd.__class__.__name__) + if self.client_manager.auth_required: + self.client_manager.auth() + + def clean_up(self, cmd, result, err): + self.LOG.debug('clean_up %s', cmd.__class__.__name__) + if err: + self.LOG.debug('got an error: %s', err) + + +def main(argv=sys.argv[1:]): + client = TestAPIClient() + return client.run(argv) + + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) 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/__init__.py b/testapi/testapi-client/testapiclient/tests/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/__init__.py diff --git a/testapi/testapi-client/testapiclient/tests/unit/__init__.py b/testapi/testapi-client/testapiclient/tests/unit/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/__init__.py diff --git a/testapi/testapi-client/testapiclient/tests/unit/fakes.py b/testapi/testapi-client/testapiclient/tests/unit/fakes.py new file mode 100644 index 0000000..8424745 --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/fakes.py @@ -0,0 +1,72 @@ +import json +import sys + +import requests +import six +import httplib + + +class FakeResponse(requests.Response): + + def __init__(self, headers=None, status_code=httplib.OK, + data=None, encoding=None): + super(FakeResponse, self).__init__() + + headers = headers or {} + + self.status_code = status_code + + self.headers.update(headers) + if status_code != httplib.OK: + self.reason = data + + self._content = json.dumps(data) + if not isinstance(self._content, six.binary_type): + self._content = self._content.encode() + + +class FakeApp(object): + + def __init__(self, _stdout, _log): + self.stdout = _stdout + self.client_manager = None + self.stdin = sys.stdin + self.stdout = _stdout or sys.stdout + self.stderr = sys.stderr + self.log = _log + + +class FakeLog(object): + + def __init__(self): + self.messages = {} + + def debug(self, msg): + self.messages['debug'] = msg + + def info(self, msg): + self.messages['info'] = msg + + def warning(self, msg): + self.messages['warning'] = msg + + def error(self, msg): + self.messages['error'] = msg + + def critical(self, msg): + self.messages['critical'] = msg + + +class FakeStdout(object): + + def __init__(self): + self.content = [] + + def write(self, text): + self.content.append(text) + + def make_string(self): + result = '' + for line in self.content: + result = result + line + return result 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_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_pods.py b/testapi/testapi-client/testapiclient/tests/unit/test_pods.py new file mode 100644 index 0000000..5d44d4c --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_pods.py @@ -0,0 +1,117 @@ +import json + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.cli import pods +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class PodTest(utils.TestCommand): + def setUp(self): + super(PodTest, 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_string = json.dumps(self.pod_json) + + +class PodGetTest(PodTest): + + def setUp(self): + super(PodGetTest, self).setUp() + self.pods_rsp = {'pods': [self.pod_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.pods_rsp) + pod_get = pods.PodGet(self.app, mock.Mock()) + args = ['-name', 'dfs'] + verifies = [('name', 'dfs')] + parsed_args = self.check_parser(pod_get, args, verifies) + pod_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '?name=dfs', + headers=clientmanager.ClientManager.headers) + + def test_get_all(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.pods_rsp) + pod_get = pods.PodGet(self.app, mock.Mock()) + args = [] + verifies = [] + parsed_args = self.check_parser(pod_get, args, verifies) + pod_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.pod_json) + pod_get_one = pods.PodGetOne(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(pod_get_one, args, verifies) + pod_get_one.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class PodCreateTest(PodTest): + + def setUp(self): + super(PodCreateTest, 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) + pod_create = pods.PodCreate(self.app, mock.Mock()) + args = [self.pod_string] + verifies = [('pod', self.pod_json)] + parsed_args = self.check_parser(pod_create, args, verifies) + pod_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 + pod_create = pods.PodCreate(self.app, mock.Mock()) + args = [self.pod_string] + verifies = [('pod', self.pod_json)] + parsed_args = self.check_parser(pod_create, args, verifies) + pod_create.take_action(parsed_args) + + +class PodDeleteTest(PodTest): + + def setUp(self): + super(PodDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + pod_delete = pods.PodDelete(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(pod_delete, args, verifies) + pod_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 + pod_delete = pods.PodDelete(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(pod_delete, args, verifies) + pod_delete.take_action(parsed_args) 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_projects.py b/testapi/testapi-client/testapiclient/tests/unit/test_projects.py new file mode 100644 index 0000000..86486ce --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/test_projects.py @@ -0,0 +1,140 @@ +import json + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.cli import projects +from testapiclient.tests.unit import fakes +from testapiclient.tests.unit import utils +from testapiclient.utils import clientmanager + + +class ProjectTest(utils.TestCommand): + def setUp(self): + super(ProjectTest, self).setUp() + self.base_url = parse.urljoin(self.api_url, 'projects') + self.project_json = { + 'name': 'test_project', + 'description': '' + } + self.project_string = json.dumps(self.project_json) + + +class ProjectGetTest(ProjectTest): + + def setUp(self): + super(ProjectGetTest, self).setUp() + self.projects_rsp = {'projects': [self.project_json]} + + def test_get(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.projects_rsp) + project_get = projects.ProjectGet(self.app, mock.Mock()) + args = ['-name', 'dfs'] + verifies = [('name', 'dfs')] + parsed_args = self.check_parser(project_get, args, verifies) + project_get.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '?name=dfs', + headers=clientmanager.ClientManager.headers) + + def test_get_all(self): + self.get_mock.return_value = fakes.FakeResponse(data=self.projects_rsp) + project_get = projects.ProjectGet(self.app, mock.Mock()) + args = [] + verifies = [] + parsed_args = self.check_parser(project_get, args, verifies) + project_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.project_json) + project_get_one = projects.ProjectGetOne(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(project_get_one, args, verifies) + project_get_one.take_action(parsed_args) + self.get_mock.assert_called_once_with( + self.base_url + '/def', + headers=clientmanager.ClientManager.headers) + + +class ProjectCreateTest(ProjectTest): + + def setUp(self): + super(ProjectCreateTest, self).setUp() + + def test_create_success(self): + succ_rsp = { + 'href': '{}/{}'.format(self.base_url, + self.project_json.get('name')) + } + self.post_mock.return_value = fakes.FakeResponse(data=succ_rsp) + project_create = projects.ProjectCreate(self.app, mock.Mock()) + args = [self.project_string] + verifies = [('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() + + def test_create_failure(self): + with testtools.ExpectedException(Exception, 'Create failed: Error'): + self.post_mock.return_value = utils.FAKE_FAILURE + project_create = projects.ProjectCreate(self.app, mock.Mock()) + args = [self.project_string] + verifies = [('project', self.project_json)] + parsed_args = self.check_parser(project_create, args, verifies) + project_create.take_action(parsed_args) + + +class ProjectDeleteTest(ProjectTest): + + def setUp(self): + super(ProjectDeleteTest, self).setUp() + + def test_delete_success(self): + self.delete_mock.return_value = fakes.FakeResponse() + project_delete = projects.ProjectDelete(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(project_delete, args, verifies) + project_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 + project_delete = projects.ProjectDelete(self.app, mock.Mock()) + args = ['def'] + verifies = [('name', 'def')] + parsed_args = self.check_parser(project_delete, args, verifies) + project_delete.take_action(parsed_args) + + +class ProjectPutTest(ProjectTest): + + def setUp(self): + super(ProjectPutTest, self).setUp() + + def test_put_success(self): + self.put_mock.return_value = fakes.FakeResponse(data=self.project_json) + project_put = projects.ProjectPut(self.app, mock.Mock()) + args = ['def', self.project_string] + verifies = [('name', 'def'), ('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() + + def test_put_failure(self): + with testtools.ExpectedException(Exception, 'Update failed: Error'): + self.put_mock.return_value = utils.FAKE_FAILURE + project_put = projects.ProjectPut(self.app, mock.Mock()) + args = ['def', self.project_string] + verifies = [('name', 'def'), ('project', self.project_json)] + parsed_args = self.check_parser(project_put, args, verifies) + project_put.take_action(parsed_args) 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 new file mode 100644 index 0000000..c59aadd --- /dev/null +++ b/testapi/testapi-client/testapiclient/tests/unit/utils.py @@ -0,0 +1,58 @@ +import httplib + +from mock import mock +from six.moves.urllib import parse +import testtools + +from testapiclient.tests.unit import fakes +from testapiclient.utils import clientmanager + +FAKE_FAILURE = fakes.FakeResponse(status_code=httplib.FORBIDDEN, data='Error') + + +class ParserException(Exception): + pass + + +class TestCommand(testtools.TestCase): + api_url = 'http://localhost:8000/api/v1/' + + def setUp(self): + super(TestCommand, self).setUp() + self.env_variables = { + 'testapi_url': 'http://localhost:8000/api/v1', + 'testapi_cas_auth_url': + ( + 'https://identity.linuxfoundation.org/user' + + '/login?destination=cas/login%3Fservice%3D' + ), + 'testapi_cas_signin_return': '/auth/signin_return' + } + self.config_mock = mock.patch.dict( + '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) + self.app.client_manager = clientmanager.ClientManager() + self.get_mock = mock.patch('requests.Session.get').start() + self.post_mock = mock.patch('requests.Session.post').start() + self.delete_mock = mock.patch('requests.Session.delete').start() + self.put_mock = mock.patch('requests.Session.put').start() + + def check_parser(self, cmd, args, verify_args): + cmd_parser = cmd.get_parser('check_parser') + try: + parsed_args = cmd_parser.parse_args(args) + except SystemExit: + raise ParserException("Argument parse failed") + for av in verify_args: + attr, value = av + if attr: + 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/__init__.py b/testapi/testapi-client/testapiclient/utils/__init__.py new file mode 100644 index 0000000..ebb891f --- /dev/null +++ b/testapi/testapi-client/testapiclient/utils/__init__.py @@ -0,0 +1,8 @@ +def get_item_properties(item, fields): + """Return a tuple containing the item properties. + + :param item: a single item resource (e.g. Server, Project, etc) + :param fields: tuple of strings with the desired field names + """ + + return tuple([item.get(field, '') for field in fields]) diff --git a/testapi/testapi-client/testapiclient/utils/clientmanager.py b/testapi/testapi-client/testapiclient/utils/clientmanager.py new file mode 100644 index 0000000..cbfd723 --- /dev/null +++ b/testapi/testapi-client/testapiclient/utils/clientmanager.py @@ -0,0 +1,87 @@ +import httplib +import json +import os +import urllib +import logging + +import requests + +LOG = logging.getLogger(__name__) + + +class ClientManager(object): + headers = { + 'Content-type': 'application/json', + 'Accept': 'text/plain'} + + def __init__(self, cli_options=None): + self.cli_options = cli_options + self.session = requests.Session() + self._auth_completed = False + + @property + def auth_required(self): + return self._auth() + + def _auth(self): + return { + 'name': self.cli_options.u, + 'pass': self.cli_options.p + } if self.cli_options.u else None + + def auth(self): + + if self._auth_completed: + return + + hostname = '{}{}{}'.format(os.environ.get('testapi_cas_auth_url'), + urllib.quote(os.environ.get('testapi_url')), + os.environ.get('testapi_cas_signin_return')) + data = self._auth() + data.update({'form_id': 'user_login'}) + LOG.debug('authenticating.....') + response = self.session.post(hostname, data) + if "login" in response.text: + raise Exception('Authenticate failed') + self._auth_completed = True + + def get(self, url): + return self._parse_response('Get', + self._request('get', url, + 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), + headers=self.headers)) + + def put(self, url, data): + return self._parse_response('Update', + self._request('put', url, + data=json.dumps(data), + headers=self.headers)) + + def delete(self, url, *args): + data = json.dumps(args[0]) if len(args) > 0 else None + return self._parse_response('Delete', + self._request('delete', url, + data=data, + headers=self.headers)) + + def _request(self, method, *args, **kwargs): + return getattr(self.session, method)(*args, **kwargs) + + def _raise_failure(self, op, response): + raise Exception('{} failed: {}'.format(op, response.reason)) + + def _parse_response(self, op, response): + if response.status_code == httplib.OK: + 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 new file mode 100644 index 0000000..b9d1ce8 --- /dev/null +++ b/testapi/testapi-client/testapiclient/utils/command.py @@ -0,0 +1,38 @@ +import abc +import logging + +from cliff import command +from cliff import lister +from cliff import show +import six + +from testapiclient import utils + + +class CommandMeta(abc.ABCMeta): + + def __new__(mcs, name, bases, cls_dict): + if 'log' not in cls_dict: + cls_dict['log'] = logging.getLogger( + cls_dict['__module__'] + '.' + name) + return super(CommandMeta, mcs).__new__(mcs, name, bases, cls_dict) + + +@six.add_metaclass(CommandMeta) +class Command(command.Command): + def run(self, parsed_args): + self.log.debug('run(%s)', parsed_args) + return super(Command, self).run(parsed_args) + + +class Lister(Command, lister.Lister): + @staticmethod + def format_output(columns, data): + return (columns, + (utils.get_item_properties(s, columns) for s in data)) + + +class ShowOne(Command, show.ShowOne): + @staticmethod + def format_output(body): + return zip(*sorted(six.iteritems(body))) diff --git a/testapi/testapi-client/testapiclient/utils/urlparse.py b/testapi/testapi-client/testapiclient/utils/urlparse.py new file mode 100644 index 0000000..47d40d5 --- /dev/null +++ b/testapi/testapi-client/testapiclient/utils/urlparse.py @@ -0,0 +1,40 @@ +import os + +from six.moves.urllib import parse + + +def path_join(base, *urls): + def _path_join(base, url): + if not base.endswith('/'): + base += '/' + return parse.urljoin(base, url) + + urls = (base,) + urls + return reduce(_path_join, urls) + + +def query_join(base, **queries): + return base + '?' + parse.urlencode(queries) + + +def resource_join(*url): + testapi_url = os.environ.get('testapi_url') + return path_join(testapi_url, *url) + + +def get_queries(queries, parsed_args): + if not isinstance(queries, list): + queries = [queries] + + return {query: getattr(parsed_args, query) + for query in queries + if hasattr(parsed_args, query) and getattr(parsed_args, query)} + + +def query_by(base, queries, parsed_args): + qs = get_queries(queries, parsed_args) + return query_join(base, **qs) if qs else base + + +def url_format(base, parsed_args): + return base.format(**(parsed_args.__dict__)) |