def setUp(self): self.gitObj = GitUtils() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.work_dir = self.base_dir + "/tests/work_dir" self.branch = "master"
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument( '-e', '--env', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument( '--skip-push', '-s', help="Don't push. Only generate components. Defaults to false.", action="store_true") parser.add_argument( '--secrets-file', '-S', help= "Specify an optional secrets file for deploy runtime variables.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" with open(self.configs_dir + '/roger_single_container_var_tests.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['container-vars'] self.config = config self.roger_env = roger_env self.data = data
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('app_name', metavar='app_name', help="application to build. Example: 'agora'.") parser.add_argument('env', metavar='env', help="environment. Example: 'test'.") parser.add_argument('directory', metavar='directory', help="working directory. Example: '/home/vagrant/work_dir'.") parser.add_argument('tag_name', metavar='tag_name', help="tag for the built image. Example: 'roger-collectd:0.20'.") parser.add_argument('config_file', metavar='config_file', help="configuration file to use. Example: 'content.json'.") parser.add_argument( '--push', '-p', help="Also push to registry. Defaults to false.", action="store_true") self.parser = parser self.args = self.parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' with open(self.configs_dir + '/app.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data
def setUp(self): self.webhook = WebHook() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) self.roger_env = roger_env
def setUp(self): self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' self.configs_dir = self.base_dir + "/tests/configs" with open(self.configs_dir + '/app.json') as config: config = json.load(config) self.config = config
def getStatsClient(self): settingObj = Settings() appObj = AppConfig() config_dir = settingObj.getConfigDir() roger_env = appObj.getRogerEnv(config_dir) statsd_url = "" statsd_port = "" if 'statsd_endpoint' in roger_env.keys(): statsd_url = roger_env['statsd_endpoint'] if 'statsd_port' in roger_env.keys(): statsd_port = int(roger_env['statsd_port']) return statsd.StatsClient(statsd_url, statsd_port)
def get_haproxy_config(self, environment): haproxy_config = "" settingObj = Settings() appObj = AppConfig() config_dir = settingObj.getConfigDir() roger_env = appObj.getRogerEnv(config_dir) host = roger_env['environments'][environment]['host'] haproxy_config_path = roger_env['environments'][ environment]['haproxy_config_path'] url = "{}{}".format(host, haproxy_config_path) haproxy_config = requests.get(url, stream=True) return haproxy_config.text
def get_proxy_config(self, environment): proxy_config = "" settingObj = Settings() appObj = AppConfig() config_dir = settingObj.getConfigDir() roger_env = appObj.getRogerEnv(config_dir) host = roger_env['environments'][environment]['host'] proxy_config_path = roger_env['environments'][ environment]['proxy_config_path'] url = "{}{}".format(host, proxy_config_path) proxy_config = requests.get(url).json() return proxy_config
def get_proxy_config(self, environment): proxy_config = "" settingObj = Settings() appObj = AppConfig() config_dir = settingObj.getConfigDir() roger_env = appObj.getRogerEnv(config_dir) host = roger_env['environments'][environment]['host'] proxy_config_path = roger_env['environments'][environment][ 'proxy_config_path'] url = "{}{}".format(host, proxy_config_path) proxy_config = requests.get(url).json() return proxy_config
def __init__(self): self.disabled = True self.emoji = ':rocket:' self.defChannel = '' self.config_dir = '' self.username = '******' self.settingObj = Settings() self.appconfigObj = AppConfig() self.configLoadFlag = False self.config = '' self.config_channels = [] self.config_envs = [] self.config_commands = []
def getRepoUrl(self, repo): if repo.startswith('*****@*****.**'): return repo else: settingObj = Settings() config_dir = settingObj.getConfigDir() roger_env = self.getRogerEnv(config_dir) if 'default_github_repo_prefix' in roger_env.keys(): prefix = roger_env['default_github_repo_prefix'] else: raise ValueError( "Could not determine github repo.Please provide default \"github repo prefix\" or ensure repo startswith [email protected]") return str(prefix + '{}.git'.format(repo))
def getRepoUrl(self, repo): if repo.startswith('*****@*****.**'): return repo else: settingObj = Settings() config_dir = settingObj.getConfigDir() roger_env = self.getRogerEnv(config_dir) if 'default_github_repo_prefix' in roger_env.keys(): prefix = roger_env['default_github_repo_prefix'] else: raise ValueError( "Could not determine github repo.Please provide default \"github repo prefix\" or ensure repo startswith [email protected]" ) return str(prefix + '{}.git'.format(repo))
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('app_name', metavar='app_name', help="application for which code is to be pulled. Example: 'agora' or 'grafana'") parser.add_argument('directory', metavar='directory', help="working directory. The repo has its own directory it this. Example: '/home/vagrant/work_dir'") parser.add_argument('-b', '--branch', metavar='branch', help="git branch to pull code from. Example: 'production' or 'master'. Defaults to master.") parser.add_argument('config_file', metavar='config_file', help="configuration file to use. Example: 'content.json' or 'kwe.json'") self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.work_dir = self.base_dir + "/tests/work_dir" self.components_dir = self.base_dir + '/tests/components/dev' self.args = parser with open(self.configs_dir + '/app.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.roger_env = roger_env self.data = data self.config = config pass
def _get_template_path(self, container_name, config_dir, args, app_name, app_object=AppConfig(), settings_object=Settings()): """ Returns the template path for a given container_name Each framework requires an template_path for the app_id method :Params: :config_dir [str]: path to the config directory :args [argparse.NameSpace]: how to get acceses to the values passed :app_name [str]: name of app :app_object [cli.appconfig.AppConfig]: instance of AppConfig :settings_object [cli.settings.Settings]: instance of Settings """ data = app_object.getConfig(config_dir, args.config) repo = self._config_resolver('repo', app_name, args.config) template_path = self._config_resolver('template_path', app_name, args.config) # this path is always relative to the root repo dir, so join if template_path and not os.path.isabs(template_path): app_path = os.path.join(self._temp_dir, repo, template_path) else: app_path = settings_object.getTemplatesDir() file_name = "{0}-{1}.json".format(data['name'], container_name) return os.path.join(app_path, file_name)
class TestBuild(unittest.TestCase): def setUp(self): self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' self.configs_dir = self.base_dir + "/tests/configs" with open(self.configs_dir + '/app.json') as config: config = json.load(config) self.config = config def test_docker_build(self): raised_exception = False try: appObj = mock(AppConfig) dockerUtilsObj = mock(DockerUtils) dockerObj = Docker() when(appObj).getRepoName(any()).thenReturn('roger') when(dockerUtilsObj).docker_build(any(), any()).thenReturn(True) directory = self.base_dir + '/tests/testrepo' config = self.config repo = config['repo'] projects = 'none' path = '' image_tag = 'test_image_tag' build_filename = '' dockerObj.docker_build(dockerUtilsObj, appObj, directory, repo, projects, path, image_tag, build_filename) except: raised_exception = True self.assertFalse(raised_exception) def tearDown(self): pass
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument( 'app_name', metavar='app_name', help= "application for which code is to be pulled. Example: 'agora' or 'grafana'" ) parser.add_argument( 'directory', metavar='directory', help= "working directory. The repo has its own directory it this. Example: '/home/vagrant/work_dir'" ) parser.add_argument( '-b', '--branch', metavar='branch', help= "git branch to pull code from. Example: 'production' or 'master'. Defaults to master." ) parser.add_argument( 'config_file', metavar='config_file', help= "configuration file to use. Example: 'content.json' or 'kwe.json'") self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.work_dir = self.base_dir + "/tests/work_dir" self.components_dir = self.base_dir + '/tests/components/dev' self.args = parser with open(self.configs_dir + '/app.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.roger_env = roger_env self.data = data self.config = config pass
def main(): args = getCliArguments() settings = Settings(args.settings) machine = machineFactory(settings) output = [] for letter in list(args.message): output.append(machine.encode(letter)) print(''.join(output))
def __init__(self, app_config=AppConfig(), settings=Settings(), framework_utils=FrameworkUtils(), framework=Marathon()): self._app_config = app_config self._settings = settings self._framework_utils = framework_utils self._framework = framework self._config_dir = None self._roger_env = None self._temp_dir = None
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--environment', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument('-s', '--skip-build', action="store_true", help="Flag that skips roger-build when set to true. Defaults to false.'") parser.add_argument('-M', '--incr-major', action="store_true", help="Increment major in version. Defaults to false.'") parser.add_argument('-p', '--incr-patch', action="store_true", help="Increment patch in version. Defaults to false.'") parser.add_argument('-sp', '--skip-push', action="store_true", help="Flag that skips roger push when set to true. Defaults to false.'") parser.add_argument( '-S', '--secrets-file', help="Specify an optional secrets file for deployment runtime variables.") parser.add_argument( '-d', '--directory', help="Specify an optional directory to pull out the repo. This is the working directory.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" config = {u'repo': u'roger', u'notifications': {u'username': u'Roger Deploy', u'method': u'chat.postMessage', u'channel': u'Channel ID', u'emoji': u':rocket:'}, u'apps': {u'test_app': {u'imageBase': u'test_app_base', u'name': u'test_app', u'containers': [u'container_name1', u'container_name2']}, u'test_app1': {u'framework': u'chronos', u'name': u'test_app1', u'containers': [u'container_name1', u'container_name2'], u'imageBase': u'test_app_base'}, u'grafana_test_app': {u'imageBase': u'test_app_base', u'name': u'test_app_grafana', u'containers': [u'grafana', {u'grafana1': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'0.5'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}, {u'grafana2': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}]}}, u'name': u'test-app', u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'1'}, u'stage': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'instances': u'1', u'network': u'BRIDGE'}}} roger_env = {u'default_environment': u'dev', u'registry': u'example.com:5000', u'environments': {u'prod': {u'chronos_endpoint': u'http://prod.example.com:4400', u'marathon_endpoint': u'http://prod.example.com:8080'}, u'dev': {u'chronos_endpoint': u'http://dev.example.com:4400', u'marathon_endpoint': u'http://dev.example.com:8080'}, u'stage': {u'chronos_endpoint': u'http://stage.example.com:4400', u'marathon_endpoint': u'http://stage.example.com:8080'}}} data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--env', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument( '--skip-push', '-s', help="Don't push. Only generate components. Defaults to false.", action="store_true") parser.add_argument( '--secrets-file', '-S', help="Specify an optional secrets file for deploy runtime variables.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' config = {u'repo': u'roger', u'act-as': u'test', u'notifications': {u'username': u'Roger Deploy', u'method': u'chat.postMessage', u'channel': u'Channel ID', u'emoji': u':rocket:'}, u'apps': {u'test_app': {u'imageBase': u'test_app_base', u'name': u'test_app', u'containers': [u'container_name1', u'container_name2']}, u'test_app1': {u'vars': {u'global': {u'env_value1': u'12', u'env_value2': u'16'}, u'environment': {u'test': {u'env_value1': u'20', u'env_value2': u'24'}}}, u'framework': u'chronos', u'name': u'test_app1', u'containers': [u'container_name1', u'container_name2'], u'imageBase': u'test_app_base'}, u'grafana_test_app': {u'imageBase': u'test_app_base', u'name': u'test_app_grafana', u'containers': [u'grafana', {u'grafana1': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'0.5'}, u'test': {u'env_value1': u'64', u'env_value2': u'128'}}, u'global': {u'mem': u'128', u'cpus': u'0.1', u'env_value1': u'30', u'env_value2': u'54'}}}}, {u'grafana2': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}]}}, u'name': u'test-app', u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'test': {u'env_value1': u'4', u'env_value2': u'8'}, u'dev': {u'mem': u'512', u'cpus': u'1'}, u'stage': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'instances': u'1', u'network': u'BRIDGE', u'env_value1': u'3', u'env_value2': u'3'}}} with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data test_config = config test_data = test_config['apps']['grafana_test_app'] self.test_config = test_config self.test_data = test_data template = Template( '{ "env": { "ENV_VAR1": "{{ env_value1 }}", "ENV_VAR2": "{{ env_value2 }}" }}') self.template = template self.additional_vars = {}
class TestInit(unittest.TestCase): def setUp(self): self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.config_dir = self.base_dir + "/tests/configs" self.template_dir = self.base_dir + "/tests/templates" pass def test_roger_init(self): set_config_dir = '' if "ROGER_CONFIG_DIR" in os.environ: set_config_dir = os.environ.get('ROGER_CONFIG_DIR') os.environ["ROGER_CONFIG_DIR"] = self.config_dir set_templ_dir = '' if "ROGER_TEMPLATES_DIR" in os.environ: set_templ_dir = os.environ.get('ROGER_TEMPLATES_DIR') os.environ["ROGER_TEMPLATES_DIR"] = self.template_dir os.system("roger init test_app roger") config_file = self.config_dir + "/app.json" template_file = self.template_dir + "/test-app-grafana.json" assert os.path.exists(config_file) is True assert os.path.exists(template_file) is True with open('{0}'.format(config_file)) as config: config = json.load(config) with open('{0}'.format(template_file)) as template: template = json.load(template) assert config['name'] == "test-app" assert len(config['apps']) == 3 for app in config['apps']: assert config['apps'][app]['name'].startswith("test_app") if len(config['apps'][app]['containers']) > 0 and type( config['apps'][app]) != dict: assert len(config['apps'][app]['containers']) == 2 for container in config['apps'][app]['containers']: assert container.startswith("container_name") assert config['apps'][app]['name'].startswith("test_app") assert template['id'] == "test-grafana" assert template['container']['type'] == "DOCKER" def tearDown(self): pass
class TestWebhook(unittest.TestCase): def setUp(self): self.webhook = WebHook() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) self.roger_env = roger_env # check for value error / exception assert # check for one positive case - May be introduce exit code or something @pytest.mark.skip def test_invoke_webhook_when_hook_input_metrics_is_invalid(self): settings = mock(Settings) appConfig = mock(AppConfig) appdata = 'valid-app-data' hook_input_metrics = 'invalid-hook-input-metrics' conf_file = 'roger-mesos-tools.config' when(settings).getConfigDir().thenReturn(self.configs_dir) when(appConfig).getRogerEnv(any()).thenReturn(self.roger_env) when(appConfig).getConfig(any(), any()).thenReturn(conf_file) with self.assertRaises(ValueError): self.webhook.invoke_webhook(appdata, hook_input_metrics, conf_file) @pytest.mark.skip def test_invoke_webhook_when_appdata_is_invalid(self): settings = mock(Settings) appConfig = mock(AppConfig) appdata = 'invalid-app-data' hook_input_metrics = 'hook-input-metrics' conf_file = 'roger-mesos-tools.config' when(settings).getConfigDir().thenReturn(self.configs_dir) when(appConfig).getRogerEnv(any()).thenReturn(self.roger_env) when(appConfig).getConfig(any(), any()).thenReturn(conf_file) with self.assertRaises(ValueError): self.webhook.invoke_webhook(appdata, hook_input_metrics, conf_file) def tearDown(self): pass
class TestWebhook(unittest.TestCase): def setUp(self): self.webhook = WebHook() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) self.roger_env = roger_env # check for value error / exception assert # check for one positive case - May be introduce exit code or something @pytest.mark.skip def test_invoke_webhook_when_hook_input_metrics_is_invalid(self): settings = mock(Settings) appConfig = mock(AppConfig) appdata = 'valid-app-data' conf_file = 'roger-mesos-tools.config' when(settings).getConfigDir().thenReturn(self.configs_dir) when(appConfig).getRogerEnv(any()).thenReturn(self.roger_env) when(appConfig).getConfig(any(), any()).thenReturn(conf_file) with self.assertRaises(ValueError): self.webhook.invoke_webhook(appdata, conf_file, any(), any(), any()) @pytest.mark.skip def test_invoke_webhook_when_appdata_is_invalid(self): settings = mock(Settings) appConfig = mock(AppConfig) appdata = 'invalid-app-data' conf_file = 'roger-mesos-tools.config' when(settings).getConfigDir().thenReturn(self.configs_dir) when(appConfig).getRogerEnv(any()).thenReturn(self.roger_env) when(appConfig).getConfig(any(), any()).thenReturn(conf_file) with self.assertRaises(ValueError): self.webhook.invoke_webhook(appdata, conf_file, any(), any(), any()) def tearDown(self): pass
class TestBuild(unittest.TestCase): def setUp(self): self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' self.configs_dir = self.base_dir + "/tests/configs" with open(self.configs_dir + '/app.json') as config: config = json.load(config) self.config = config def test_docker_build(self): raised_exception = False try: appObj = mock(AppConfig) dockerUtilsObj = mock(DockerUtils) dockerObj = Docker() when(appObj).getRepoName(any()).thenReturn('roger') when(dockerUtilsObj).docker_build(any(), any()).thenReturn(True) directory = self.base_dir + '/tests/testrepo' config = self.config repo = config['repo'] projects = 'none' path = '' image_tag = 'test_image_tag' build_filename = '' verbose_mode = False dockerObj.docker_build(dockerUtilsObj, appObj, directory, repo, projects, path, image_tag, verbose_mode, build_filename) except (Exception) as e: print("Build error is: ") print(e) raised_exception = True self.assertFalse(raised_exception) def tearDown(self): pass
def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--env', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument( '--skip-push', '-s', help="Don't push. Only generate components. Defaults to false.", action="store_true") parser.add_argument('--secrets-file', '-S', help="Specify an optional secrets file for deploy runtime variables.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" with open(self.configs_dir + '/roger_single_container_var_tests.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['container-vars'] self.config = config self.roger_env = roger_env self.data = data
class TestAppConfig(unittest.TestCase): def setUp(self): self.appObj = AppConfig() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" def test_getRogerEnv(self): roger_env = self.appObj.getRogerEnv(self.configs_dir) assert roger_env['registry'] == "example.com:5000" assert roger_env['default_environment'] == "dev" assert roger_env['environments']['dev'][ 'marathon_endpoint'] == "http://dev.example.com:8080" assert roger_env['environments']['prod'][ 'chronos_endpoint'] == "http://prod.example.com:4400" def test_getConfig(self): config = self.appObj.getConfig(self.configs_dir, "app.json") assert config['name'] == "test-app" assert config['repo'] == "roger" assert config['vars']['environment']['prod']['mem'] == "2048" assert len(config['apps'].keys()) == 3 for app in config['apps']: assert "test_app" in app assert config['apps'][app]['imageBase'] == "test_app_base" def test_getAppData(self): app_data = self.appObj.getAppData(self.configs_dir, "app.json", "app_name") assert app_data == '' app_data = self.appObj.getAppData(self.configs_dir, "app.json", "test_app") assert app_data['imageBase'] == "test_app_base" assert len(app_data['containers']) == 2 def tearDown(self): pass
class TestGitPull(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('app_name', metavar='app_name', help="application for which code is to be pulled. Example: 'agora' or 'grafana'") parser.add_argument('directory', metavar='directory', help="working directory. The repo has its own directory it this. Example: '/home/vagrant/work_dir'") parser.add_argument('-b', '--branch', metavar='branch', help="git branch to pull code from. Example: 'production' or 'master'. Defaults to master.") parser.add_argument('config_file', metavar='config_file', help="configuration file to use. Example: 'content.json' or 'kwe.json'") self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.work_dir = self.base_dir + "/tests/work_dir" self.components_dir = self.base_dir + '/tests/components/dev' self.args = parser with open(self.configs_dir + '/app.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.roger_env = roger_env self.data = data self.config = config pass def test_rogerGitPull(self): set_config_dir = '' if "ROGER_CONFIG_DIR" in os.environ: set_config_dir = os.environ.get('ROGER_CONFIG_DIR') os.environ["ROGER_CONFIG_DIR"] = self.configs_dir config_file = "app.json" work_dir = self.work_dir settings = mock(Settings) appConfig = mock(AppConfig) roger_gitpull = RogerGitPull() roger_gitpull.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) gitObj = mock(GitUtils) data = self.data config = self.config roger_env = self.roger_env repo_name = 'roger' when(roger_gitpull.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_gitpull.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(self.components_dir + '/test-roger-grafana.json', roger_env['environments']['dev'], 'grafana_test_app').thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig( self.configs_dir, "app.json").thenReturn(config) when(appConfig).getAppData(self.configs_dir, "app.json", "grafana_test_app").thenReturn(data) when(appConfig).getRepoName(any()).thenReturn(repo_name) args = self.args args.app_name = "grafana_test_app" args.config_file = config_file args.branch = "master" args.environment = 'test' args.directory = self.work_dir args.verbose = False when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) raised_exception = False try: return_code = roger_gitpull.main(settings, appConfig, gitObj, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertTrue(raised_exception) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) exists = os.path.exists(work_dir) assert exists is True shutil.rmtree(work_dir) if set_config_dir.strip() != '': os.environ["ROGER_CONFIG_DIR"] = "{}".format(set_config_dir) def test_roger_gitpull_calls_pregitpull_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_gitpull = RogerGitPull() mockedHooks = mock(Hooks) gitObj = mock(GitUtils) roger_env = {} roger_env["registry"] = "any registry" when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata = {} appdata["hooks"] = dict([("pre_gitpull", "some command")]) repo_name = 'roger' when(settings).getConfigDir().thenReturn(self.configs_dir) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) config = self.config when(roger_gitpull.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_gitpull.utils).extract_app_name(any()).thenReturn("test") when(settings).getUser().thenReturn('test_user') when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getRepoName(any()).thenReturn(repo_name) args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.environment = 'test' args.branch = "some_branch" args.directory = '/tmp' args.verbose = False when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) raised_exception = False try: return_code = roger_gitpull.main(settings, appConfig, gitObj, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertTrue(raised_exception) verify(mockedHooks).run_hook("pre_gitpull", any(), any(), any()) def test_roger_gitpull_calls_postgitpull_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_gitpull = RogerGitPull() roger_gitpull.utils = mock(Utils) mockedHooks = mock(Hooks) gitObj = mock(GitUtils) roger_env = {} repo_name = 'roger' repo_url = 'test_url' roger_env["registry"] = "any registry" when(settings).getConfigDir().thenReturn(self.configs_dir) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata = {} appdata["hooks"] = dict([("post_gitpull", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) config = self.config when(roger_gitpull.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_gitpull.utils).extract_app_name(any()).thenReturn("test") when(settings).getUser().thenReturn('test_user') when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.branch = "some_branch" args.directory = '/tmp' args.environment = 'test' args.verbose = False when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) raised_exception = False try: return_code = roger_gitpull.main(settings, appConfig, gitObj, mockedHooks, args) verify(mockedHooks).run_hook("post_gitpull", any(), any(), any()) except (Exception) as e: raised_exception = True self.assertTrue(raised_exception) def tearDown(self): pass
import json import yaml import re from jinja2 import Environment, FileSystemLoader from termcolor import colored from cli.framework import Framework from cli.utils import Utils from cli.settings import Settings from cli.marathonvalidator import MarathonValidator from cli.proxyparser import ProxyParser from cli.appconfig import AppConfig from distutils.version import LooseVersion requests.packages.urllib3.disable_warnings() utils = Utils() settings = Settings() class Marathon(Framework): def __init__(self): self.user = None self.passw = None self.marathonvalidator = MarathonValidator() self.proxyparser = ProxyParser() def getName(self): return "Marathon" def get(self, roger_env, environment): url = roger_env['environments'][environment][ 'marathon_endpoint'] + "/v2/apps"
class TestInit(unittest.TestCase): def setUp(self): self.gitObj = GitUtils() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.work_dir = self.base_dir + "/tests/work_dir" self.branch = "master" @pytest.mark.skip def test_gitPull(self): config_file = "app.json" work_dir = self.work_dir branch = self.branch if not os.path.exists(self.work_dir): try: os.makedirs(self.work_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise os.chdir(self.work_dir) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) repo = config['repo'] return_code = self.gitObj.gitClone(repo, branch) assert return_code == 0 exists = os.path.exists(work_dir) assert exists is True os.chdir("{}/{}".format(work_dir, repo)) return_code = self.gitObj.gitPull(self.branch) assert return_code == 0 assert exists is True exists = os.path.exists("{}/{}".format(work_dir, repo)) assert exists is True exists = os.path.exists("{}/{}/ansible".format(work_dir, repo)) assert exists is True shutil.rmtree(work_dir) pass @pytest.mark.skip def test_gitShallowClone(self): config_file = "app.json" work_dir = self.work_dir branch = self.branch if not os.path.exists(self.work_dir): try: os.makedirs(self.work_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise os.chdir(self.work_dir) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) repo = config['repo'] return_code = self.gitObj.gitShallowClone(repo, branch) assert return_code == 0 exists = os.path.exists(work_dir) assert exists is True exists = os.path.exists("{}/{}".format(work_dir, repo)) assert exists is True exists = os.path.exists("{}/{}/ansible".format(work_dir, repo)) assert exists is True shutil.rmtree(work_dir) @pytest.mark.skip def test_gitClone(self): config_file = "app.json" work_dir = self.work_dir branch = self.branch if not os.path.exists(self.work_dir): try: os.makedirs(self.work_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise os.chdir(self.work_dir) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) repo = config['repo'] return_code = self.gitObj.gitClone(repo, branch) assert return_code == 0 exists = os.path.exists(work_dir) assert exists is True exists = os.path.exists("{}/{}".format(work_dir, repo)) assert exists is True exists = os.path.exists("{}/{}/ansible".format(work_dir, repo)) assert exists is True shutil.rmtree(work_dir) def tearDown(self): pass
class WebHook: def __init__(self): self.disabled = True self.emoji = ':rocket:' self.defChannel = '' self.config_dir = '' self.username = '******' self.settingObj = Settings() self.appconfigObj = AppConfig() self.configLoadFlag = False self.config = '' self.config_channels = [] self.config_envs = [] self.config_commands = [] def webhookSetting(self): """ Prepares webhook setting from roger-mesos-tools.config file File should have all the required variables otherwise it exits with a warning message """ try: self.config_dir = self.settingObj.getConfigDir() roger_env = self.appconfigObj.getRogerEnv(self.config_dir) if 'slack_webhook_url' in roger_env.keys(): self.webhookURL = roger_env['slack_webhook_url'] if 'slack_api_token' in roger_env.keys(): self.token = roger_env['slack_api_token'] if 'slack_default_channel' in roger_env.keys(): self.defChannel = roger_env['slack_default_channel'] if 'slack_deploy_botid' in roger_env.keys(): self.botid = roger_env['slack_deploy_botid'] except (Exception) as e: print("Warning: slackweb basic initialization failed (error: %s).\ Not using slack." % e) return try: self.sc = SlackClient(self.token) self.client = slackweb.Slack(url=self.webhookURL) self.disabled = False except (Exception) as e: print("Warning: slackweb basic initialization failed (error: %s).\ Not using slack." % e) return # disabled flag remains False def custom_api_call(self, text, channel): """ Makes the webhook call Keyword arguments: text -- message to be posted channel -- to which channel posts a message if rogeros - bot is present """ try: self.webhookSetting() if len(channel) == 0: channel = self.defChannel var = self.sc.api_call("channels.list") length = len(var['channels']) for iterator in range(0, length): # getting rid of # for comparison if channel[1:] == var['channels'][iterator]['name']: if self.botid in var['channels'][iterator]['members']: if not self.disabled: self.client.notify(channel=channel, username=self.username, icon_emoji=self.emoji, text=text) except (Exception) as e: # notify to channel and log it as well printException(e) raise def areBasicKeysAvailableInConfig(self, config): if 'notifications' not in config: return False tempList = config['notifications'].keys() if 'channels' not in tempList: return False # if no channel is available nothing can be done if 'envs' not in tempList: self.config_envs = ['dev', 'production', 'staging', 'local'] if 'commands' not in tempList: self.config_commands = ['pull', 'build', 'push'] return True def areBasicKeysAvailableInAppdata(self, appdata): tempList = appdata.keys() if 'notifications' not in tempList: return False appKeys = appdata['notifications'].keys() if 'channels' not in appKeys: return False return True def configLevelSettings(self, config_file): """ Prepares all the config_level settings as variables Keyword arguments: config_file -- This is the file name passed as argument return three sets of channels, envs and commands. self variable as config level variable not expected to change for the run """ if (not self.configLoadFlag): self.config = self.appconfigObj.getConfig(self.config_dir, config_file) self.configLoadFlag = True if(not self.areBasicKeysAvailableInConfig(self.config)): return try: self.config_channels = Set(self.config['notifications']['channels']) if 'envs' in self.config['notifications'].keys(): self.config_envs = Set(self.config['notifications']['envs']) if 'commands' in self.config['notifications'].keys(): self.config_commands = Set(self.config['notifications']['commands']) if (len(self.config_channels) == 0 or len(self.config_envs) == 0 or len(self.config_commands) == 0): return except (Exception, KeyError, ValueError) as e: # notify to channel and log it as well printException(e) raise def invoke_webhook(self, appdata, config_file, action, env, user): """ Pepares set and posts to slack channel Keyword arguments: appdata -- this is value related to an app hook_input_metric -- value it gets from hook class per app config_file -- the file name under for the app deployment """ envSet = [] commandsSet = [] self.function_execution_start_time = datetime.now() self.webhookSetting() self.configLevelSettings(config_file) self.action = action self.envr = env self.user = user self.app_name = appdata['name'] try: if(not self.areBasicKeysAvailableInAppdata(appdata)): return if 'notifications' in appdata: channelsSet = Set(appdata['notifications']['channels']) # to handle if tag is there but no data is present if (len(self.config_channels) != 0): channelsSet = channelsSet.union(self.config_channels) # to handle if tag is there if 'envs' in appdata['notifications'].keys(): envSet = Set(appdata['notifications']['envs']) # to handle if tag is there but data is not there if (len(self.config_envs) != 0): envSet = envSet.union(self.config_envs) if 'commands' in appdata['notifications'].keys(): commandsSet = Set(appdata['notifications']['commands']) if (len(self.config_commands) != 0): commandsSet = commandsSet.union(self.config_commands) if (len(channelsSet) == 0 or len(envSet) == 0 or len(commandsSet) == 0): return else: if list(self.config_envs)[0] == 'all': self.config_envs = ['dev', 'production', 'staging', 'local'] if list(self.config_commands)[0] == 'all': self.config_commands = ['pull', 'build', 'push'] self.postToSlack(self.action, self.config_envs, self.config_commands, self.config_channels) return if list(envSet)[0] == 'all': envSet = ['dev', 'production', 'staging', 'local'] if list(commandsSet)[0] == 'all': commandsSet = ['pull', 'build', 'push'] except (Exception, KeyError, ValueError) as e: printException(e) raise try: self.postToSlack(self.action, envSet, commandsSet, channelsSet) except (Exception) as e: self.custom_api_call("Error : %s" % e, self.defChannel) printException(e) raise def postToSlack(self, action, envSet, commandsSet, channelsSet): """ Prepares post to slack channel Keyword arguments: action -- action extracted from hookname_input_metric envSet -- set of accepted environment commandsSet -- set of accepted commandssets channelsSet -- set of accepted channelsets """ try: if ('post' in action and self.envr in envSet and action.split('_')[1] in commandsSet): for channel in channelsSet: timeElapsed = '{0:.2f}'.format((datetime.now() - self.function_execution_start_time).total_seconds() * 1000) timeasInt = float(timeElapsed) h, m, s, ms = self.makeTimeReadable(timeasInt) readableTime = self.createMesage(h, m, s, ms) slackMessage = ("Completed *" + action.split('_')[1] + "* of *" + self.app_name + "* on *" + self.envr + "* in *" + readableTime + "* (triggered by *" + self.user + "*)") self.custom_api_call(slackMessage, '#' + channel) except (Exception) as e: self.custom_api_call("Error : %s" % e, self.defChannel) printException(e) raise def makeTimeReadable(self, ms): """ Make time readable Keyword arguments: ms -- time in miliseconds """ s = ms / 1000 m, s = divmod(s, 60) h, m = divmod(m, 60) return h, m, s, ms def createMesage(self, h, m, s, ms): message = '' if int(h) > 0: message += str(int(h)) + "h " if int(m) > 0: message += str(int(m)) + "m " if int(s) > 0: message += str(int(s)) + "s " message += str(ms) + "ms " return message
class TestPush(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--env', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument( '--skip-push', '-s', help="Don't push. Only generate components. Defaults to false.", action="store_true") parser.add_argument( '--secrets-file', '-S', help="Specify an optional secrets file for deploy runtime variables.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' config = {u'repo': u'roger', u'act-as': u'test', u'notifications': {u'username': u'Roger Deploy', u'method': u'chat.postMessage', u'channel': u'Channel ID', u'emoji': u':rocket:'}, u'apps': {u'test_app': {u'imageBase': u'test_app_base', u'name': u'test_app', u'containers': [u'container_name1', u'container_name2']}, u'test_app1': {u'vars': {u'global': {u'env_value1': u'12', u'env_value2': u'16'}, u'environment': {u'test': {u'env_value1': u'20', u'env_value2': u'24'}}}, u'framework': u'chronos', u'name': u'test_app1', u'containers': [u'container_name1', u'container_name2'], u'imageBase': u'test_app_base'}, u'grafana_test_app': {u'imageBase': u'test_app_base', u'name': u'test_app_grafana', u'containers': [u'grafana', {u'grafana1': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'0.5'}, u'test': {u'env_value1': u'64', u'env_value2': u'128'}}, u'global': {u'mem': u'128', u'cpus': u'0.1', u'env_value1': u'30', u'env_value2': u'54'}}}}, {u'grafana2': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}]}}, u'name': u'test-app', u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'test': {u'env_value1': u'4', u'env_value2': u'8'}, u'dev': {u'mem': u'512', u'cpus': u'1'}, u'stage': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'instances': u'1', u'network': u'BRIDGE', u'env_value1': u'3', u'env_value2': u'3'}}} with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data test_config = config test_data = test_config['apps']['grafana_test_app'] self.test_config = test_config self.test_data = test_data template = Template( '{ "env": { "ENV_VAR1": "{{ env_value1 }}", "ENV_VAR2": "{{ env_value2 }}" }}') self.template = template self.additional_vars = {} def test_template_render_for_extra_variables(self): roger_push = RogerPush() app_data = self.config['apps']['grafana_test_app'] container = app_data['containers'][1]['grafana1'] additional_vars = self.additional_vars additional_vars['env_value1'] = "100" additional_vars['env_value2'] = "200" output = roger_push.renderTemplate( self.template, "test", "test_image", app_data, self.config, container, "grafana1", additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '100' assert result['env']['ENV_VAR2'] == '200' def test_template_render_for_config_level_variables(self): roger_push = RogerPush() app_data = self.config['apps']['test_app'] container = "container_name1" output = roger_push.renderTemplate( self.template, "test", "test_image", app_data, self.config, container, "container_name1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '4' assert result['env']['ENV_VAR2'] == '8' def test_template_render_for_app_level_variables(self): roger_push = RogerPush() app_data = self.config['apps']['test_app1'] container = "container_name1" # Passing environment that doesn't exist output = roger_push.renderTemplate(self.template, "non_existing_env", "test_image", app_data, self.config, container, "container_name1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '12' assert result['env']['ENV_VAR2'] == '16' # Existing environment output = roger_push.renderTemplate( self.template, "test", "test_image", app_data, self.config, container, "container_name1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '20' assert result['env']['ENV_VAR2'] == '24' def test_template_render_for_container_level_variables(self): roger_push = RogerPush() app_data = self.config['apps']['grafana_test_app'] container = "grafana" # Passing environment that doesn't exist output = roger_push.renderTemplate(self.template, "non_existing_env", "test_image", app_data, self.config, container, "grafana", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '3' assert result['env']['ENV_VAR2'] == '3' # Existing environment output = roger_push.renderTemplate( self.template, "test", "test_image", app_data, self.config, container, "grafana", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '4' assert result['env']['ENV_VAR2'] == '8' container = app_data['containers'][1]['grafana1'] output = roger_push.renderTemplate(self.template, "non_existing_env", "test_image", app_data, self.config, container, "grafana1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '30' assert result['env']['ENV_VAR2'] == '54' output = roger_push.renderTemplate( self.template, "test", "test_image", app_data, self.config, container, "grafana1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '64' assert result['env']['ENV_VAR2'] == '128' def test_roger_push_grafana_test_app(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn("Response [200]", any()) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) with open(self.base_dir + '/tests/templates/test-app-grafana.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" verify(settings).getConfigDir() verify(settings).getComponentsDir() verify(settings).getTemplatesDir() verify(settings).getSecretsDir() verify(frameworkUtils).getFramework(data) def test_container_resolution(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.test_config data = self.test_data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).getName().thenReturn('Marathon') when(marathon).put(any(), any(), any()).thenReturn("Response [200]") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.directory = self.base_dir + '/tests/testrepo' args.config_file = 'test.json' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) with open(self.base_dir + '/tests/templates/test-app-grafana.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" assert output['cpus'] == 2 assert output['mem'] == 1024 assert output['uris'] == ["abc", "xyz", "$ENV_VAR"] with open(self.base_dir + '/tests/templates/test-app-grafana1.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" assert output['cpus'] == 0.5 assert output['mem'] == 512 with open(self.base_dir + '/tests/templates/test-app-grafana2.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" assert output['cpus'] == 1 assert output['mem'] == 1024 def test_roger_push_with_no_app_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.app_name = '' args.config_file = 'test.json' args.env = 'some_test_env' with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_no_registry_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' config_dir = settings.getConfigDir() roger_env = appConfig.getRogerEnv(config_dir) # Remove registry key from dictionary del roger_env['registry'] with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_no_environment_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args # Set environment variable as None args.env = '' args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_unresolved_jinja_variable_fails(self): with open(self.configs_dir + '/roger_push_unresolved_jinja.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['container-vars'] self.config = config self.roger_env = roger_env self.data = data settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(roger_push.utils).get_version().thenReturn(any()) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(self.configs_dir, "roger_push_unresolved_jinja.json").thenReturn(config) when(appConfig).getAppData(self.configs_dir, "roger_push_unresolved_jinja.json", "container-vars").thenReturn(data) args = self.args args.env = "dev" args.skip_push = False args.force_push = False args.secrets_dir = "" args.secrets_file = "" args.app_name = 'container-vars' args.config_file = 'roger_push_unresolved_jinja.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'tests/v0.1.0' args.verbose = False roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(frameworkUtils, times=0).put(any(), any(), any(), any()) def test_roger_push_calls_prepush_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) frameworkUtils = mock(FrameworkUtils) roger_env = self.roger_env appdata = self.data config = self.config sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(any()).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata["hooks"] = dict([("pre_push", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.env = 'dev' args.image_name = 'tests/v0.1.0' args.directory = '/tmp' args.secrets_file = "" args.skip_push = True args.verbose = False raised_exception = False try: return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertFalse(raised_exception) verify(mockedHooks).run_hook("pre_push", any(), any(), any()) def test_roger_push_calls_postpush_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) frameworkUtils = mock(FrameworkUtils) roger_env = self.roger_env appdata = self.data config = self.config sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(any()).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata["hooks"] = dict([("post_push", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.env = 'dev' args.image_name = 'tests/v0.1.0' args.directory = '/tmp' args.secrets_file = "" args.skip_push = True args.verbose = False raised_exception = False try: return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertFalse(raised_exception) verify(mockedHooks).run_hook("post_push", any(), any(), any()) def test_roger_push_verify_default_env_use(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config frameworkUtils = mock(FrameworkUtils) when(settings).getConfigDir().thenReturn(self.configs_dir) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = None args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' roger_env = appConfig.getRogerEnv(self.configs_dir) roger_env["default_environment"] = "test_env" with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_incorrect_container_name(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config appdata = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") frameworkUtils = mock(FrameworkUtils) when(marathon).getName().thenReturn('Marathon') when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app:test' args.config_file = 'test.json' with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_correct_container_name(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) frameworkUtils = mock(FrameworkUtils) roger_env = self.roger_env appdata = self.data config = self.config sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(any()).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata["hooks"] = dict([("post_push", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app:grafana' args.config_file = 'test.json' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False raised_exception = False try: roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertFalse(raised_exception) verify(frameworkUtils).getFramework(any()) def test_roger_push_env_from_ROGER_ENV_VAR(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config frameworkUtils = mock(FrameworkUtils) when(settings).getConfigDir().thenReturn(self.configs_dir) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = None args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' roger_env = appConfig.getRogerEnv(self.configs_dir) roger_env["default_environment"] = None # Setting ROGER_ENV to specific value os.environ["ROGER_ENV"] = "test_env" with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_push_happens_with_validation_error_when_force_push_set(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data when(marathon).getName().thenReturn('Marathon') when(marathon).put(any(), any(), any(), any(), any()).thenReturn(["Response [200]", any()]) when(marathon).runDeploymentChecks(any(), any()).thenReturn(True) frameworkUtils = mock(FrameworkUtils) frameworkUtils = mock(FrameworkUtils) sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(roger_push.utils).modify_task_id(any()).thenReturn([any()]) when(roger_push.utils).get_version().thenReturn(any()) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = False args.force_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False raised_exception = False try: roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertFalse(raised_exception) def test_roger_push_skip_push_set(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn(["Response [200]", any()]) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False return_code = roger_push.main( settings, appConfig, frameworkUtils, mockedHooks, args) verify(frameworkUtils, times=0).runDeploymentChecks(any(), any()) def test_push_fails_with_validation_error(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(roger_push.utils).modify_task_id(any()).thenReturn([any()]) when(roger_push.utils).get_version().thenReturn(any()) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(marathon).put(any(), any(), any(), any(), any()).thenReturn(["Response [200]", any()]) when(marathon).runDeploymentChecks(any(), any()).thenReturn(True) when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = False args.force_push = False args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False raised_exception = False try: return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) except (Exception) as e: raised_exception = True self.assertFalse(raised_exception) verify(frameworkUtils, times=0).put(any(), any(), any(), any()) def test_roger_push_secrets_replaced(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' args.verbose = False exit_code = roger_push.main( settings, appConfig, frameworkUtils, mockedHooks, args) file_path = ("{0}/{1}/{2}".format(self.components_dir, args.env, args.config_file)) assert (os.path.isfile(file_path) is not True) def test_secret_vars_replacement_for_no_secrets_file(self): args = self.args args.env = "test" args.secrets_file = "" args.app_name = 'test_app' args.image_name = 'test_image' args.verbose = False secrets_dir = self.base_dir + "/tests/secrets" roger_push = RogerPush() app_data = self.config['apps'][args.app_name] container = "container1" additional_vars = self.additional_vars extra_vars = {} extra_vars['env_value1'] = "100" extra_vars['env_value2'] = "200" additional_vars.update(extra_vars) secret_vars = roger_push.loadSecrets( secrets_dir, args.secrets_file, args, args.env) additional_vars.update(secret_vars) output = roger_push.renderTemplate( self.template, args.env, args.image_name, app_data, self.config, container, "container1", additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '100' assert result['env']['ENV_VAR2'] == '200' def test_secret_vars_replacement_with_secrets_file(self): args = self.args args.env = "test" args.secrets_file = "test_app-container1.json" args.app_name = 'test_app' args.image_name = 'test_image' args.verbose = False secrets_dir = self.base_dir + "/tests/secrets" roger_push = RogerPush() app_data = self.config['apps'][args.app_name] container = "container1" additional_vars = self.additional_vars extra_vars = {} extra_vars['env_value1'] = "100" extra_vars['env_value2'] = "200" additional_vars.update(extra_vars) secret_vars = roger_push.loadSecrets( secrets_dir, args.secrets_file, args, args.env) print(secret_vars) additional_vars.update(secret_vars) output = roger_push.renderTemplate( self.template, args.env, args.image_name, app_data, self.config, container, "container1", additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == 'test_value1' assert result['env']['ENV_VAR2'] == 'test_value2' def tearDown(self): pass
def main(self, settingObject, appObject, frameworkUtilsObject, gitObj, hooksObj, args): try: function_execution_start_time = datetime.now() execution_result = 'SUCCESS' settingObj = settingObject appObj = appObject config_dir = settingObj.getConfigDir() root = settingObj.getCliDir() roger_env = appObj.getRogerEnv(config_dir) config = appObj.getConfig(config_dir, args.config_file) config_name = "" if 'name' in config: config_name = config['name'] if 'registry' not in roger_env: raise ValueError('Registry not found in roger-mesos-tools.config file.') else: self.registry = roger_env['registry'] # Setup for Slack-Client, token, and git user # (vmahedia) todo: ExtractClass Notifications, it should know who all to notify on what event # Event should be registered and SlackNotification should be one of the members. it can have # N notifications on a particular "event", Notifications.Notify will broadcast notification to # all the interested parties. if 'notifications' in config: self.slack = Slack(config['notifications'], '/home/vagrant/.roger_cli.conf.d/slack_token') self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.application) apps = [] apps_container_dict = {} if args.application == 'all': apps = config['apps'].keys() else: if ":" not in args.application and "[" not in args.application: apps.append(args.application) else: for item in args.application.split(":"): if '[' in item: matchObj = re.match(r'(.*)\[(.*)\]', item) apps.append(matchObj.group(1)) apps_container_dict[matchObj.group(1)] = matchObj.group(2) else: apps.append(item) common_repo = config.get('repo', '') environment = roger_env.get('default_environment', '') work_dir = '' if args.directory: work_dir = args.directory temp_dir_created = False if args.verbose: print("Using {0} as the working directory".format(work_dir)) else: work_dir = mkdtemp() temp_dir_created = True if args.verbose: print("Created a temporary dir: {0}".format(work_dir)) if args.environment is None: if "ROGER_ENV" in os.environ: env_var = os.environ.get('ROGER_ENV') if env_var.strip() == '': print( "Environment variable $ROGER_ENV is not set. Using the default set from roger-mesos-tools.config file") else: print( "Using value {} from environment variable $ROGER_ENV".format(env_var)) environment = env_var else: environment = args.environment if environment not in roger_env['environments']: self.removeDirTree(work_dir, args, temp_dir_created) raise ValueError('Environment not found in roger-mesos-tools.config file.') branch = "master" # master by default if args.branch is not None: branch = args.branch try: for app in apps: if app not in config['apps']: raise ValueError('Application {} specified not found.'.format(app)) else: try: if args.verbose: print("Deploying {} ...".format(app)) self.deployApp(settingObject, appObject, frameworkUtilsObject, gitObj, hooksObj, root, args, config, roger_env, work_dir, config_dir, environment, app, branch, self.slack, args.config_file, common_repo, temp_dir_created, apps_container_dict) except (IOError, ValueError) as e: error_msg = "Error when deploying {}: {}".format(app, repr(e)) printErrorMsg(error_msg) pass # try deploying the next app except (Exception) as e: printException(e) raise except (Exception) as e: execution_result = 'FAILURE' printException(e) raise finally: # Check if the initializition of variables carried out if 'function_execution_start_time' not in globals() and 'function_execution_start_time' not in locals(): function_execution_start_time = datetime.now() if 'execution_result' not in globals() and 'execution_result' not in locals(): execution_result = 'FAILURE' if 'config_name' not in globals() and 'config_name' not in locals(): config_name = "" if 'environment' not in globals() and 'environment' not in locals(): environment = "dev" if not hasattr(args, "application"): args.application = "" if 'settingObj' not in globals() and 'settingObj' not in locals(): settingObj = Settings() if 'work_dir' not in globals() and 'work_dir' not in locals(): work_dir = '' temp_dir_created = False if not (self.rogerGitPullObject.outcome is 1 and self.rogerBuildObject.outcome is 1 and self.rogerPushObject.outcome is 1): execution_result = 'FAILURE' try: # If the deploy fails before going through any steps sc = self.utils.getStatsClient() if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.application) args.application = self.utils.extract_app_name(args.application) time_take_milliseonds = ((datetime.now() - function_execution_start_time).total_seconds() * 1000) input_metric = "roger-tools.rogeros_tools_exec_time," + "app_name=" + str(args.application) + ",event=deploy" + ",outcome=" + str(execution_result) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******",identifier=" + str(self.identifier) tup = (input_metric, time_take_milliseonds) self.statsd_message_list.append(tup) self.removeDirTree(work_dir, args, temp_dir_created) except (Exception) as e: error_msg = "Error when deploying {}: {}".format(app, repr(e)) printErrorMsg(error_msg) raise
self.task_id.extend(container_task_id) except (Exception) as e: print("ERROR - : %s" %e, file=sys.stderr) execution_result = 'FAILURE' raise finally: # todo: maybe send datadog event from here? pass hookname = "post_push" exit_code = hooksObj.run_hook(hookname, data, app_path, args.env, settingObj.getUser()) if exit_code != 0: raise ValueError("{} hook failed.".format(hookname)) print(colored("******Done with the PUSH step******", "green")) except (Exception) as e: raise ValueError("ERROR - {}".format(e)) if __name__ == "__main__": settingObj = Settings() appObj = AppConfig() frameworkUtils = FrameworkUtils() hooksObj = Hooks() roger_push = RogerPush() try: roger_push.parser = roger_push.parse_args() roger_push.args = roger_push.parser.parse_args() roger_push.main(settingObj, appObj, frameworkUtils, hooksObj, roger_push.args) except (Exception) as e: printException(e)
class TestInit(unittest.TestCase): def setUp(self): self.gitObj = GitUtils() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.work_dir = self.base_dir + "/tests/work_dir" self.branch = "master" @pytest.mark.skip def test_gitPull(self): config_file = "app.json" work_dir = self.work_dir branch = self.branch if not os.path.exists(self.work_dir): try: os.makedirs(self.work_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise os.chdir(self.work_dir) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) repo = config['repo'] return_code = self.gitObj.gitClone(repo, branch) assert return_code == 0 exists = os.path.exists(work_dir) assert exists is True os.chdir("{}/{}".format(work_dir, repo)) return_code = self.gitObj.gitPull(self.branch) assert return_code == 0 assert exists is True exists = os.path.exists("{}/{}".format(work_dir, repo)) assert exists is True exists = os.path.exists("{}/{}/ansible".format(work_dir, repo)) assert exists is True shutil.rmtree(work_dir) pass @pytest.mark.skip def test_gitShallowClone(self): config_file = "app.json" work_dir = self.work_dir branch = self.branch if not os.path.exists(self.work_dir): try: os.makedirs(self.work_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise os.chdir(self.work_dir) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) repo = config['repo'] verbose_mode = False return_code = self.gitObj.gitShallowClone(repo, branch, verbose_mode) assert return_code == 0 exists = os.path.exists(work_dir) assert exists is True exists = os.path.exists("{}/{}".format(work_dir, repo)) assert exists is True exists = os.path.exists("{}/{}/ansible".format(work_dir, repo)) assert exists is True shutil.rmtree(work_dir) @pytest.mark.skip def test_gitClone(self): config_file = "app.json" work_dir = self.work_dir branch = self.branch if not os.path.exists(self.work_dir): try: os.makedirs(self.work_dir) except OSError as exception: if exception.errno != errno.EEXIST: raise os.chdir(self.work_dir) with open(self.configs_dir + '/{}'.format(config_file)) as config: config = json.load(config) repo = config['repo'] return_code = self.gitObj.gitClone(repo, branch) assert return_code == 0 exists = os.path.exists(work_dir) assert exists is True exists = os.path.exists("{}/{}".format(work_dir, repo)) assert exists is True exists = os.path.exists("{}/{}/ansible".format(work_dir, repo)) assert exists is True shutil.rmtree(work_dir) def tearDown(self): pass
def main(self, settings, appConfig, gitObject, hooksObj, args): try: function_execution_start_time = datetime.now() execution_result = 'SUCCESS' # Assume the execution_result to be SUCCESS unless exception occurs environment = "dev" if hasattr(args, "environment"): environment = args.environment settingObj = settings appObj = appConfig gitObj = gitObject config_dir = settingObj.getConfigDir() hooksObj.config_file = args.config_file config = appObj.getConfig(config_dir, args.config_file) config_name = "" if 'name' in config: config_name = config['name'] common_repo = config.get('repo', '') data = appObj.getAppData(config_dir, args.config_file, args.app_name) if not data: raise ValueError('Application with name [{}] or data for it not found at {}/{}.'.format( args.app_name, config_dir, args.config_file)) repo = '' if common_repo != '': repo = data.get('repo', common_repo) else: repo = data.get('repo', args.app_name) branch = "master" # master by default if args.branch is not None: branch = args.branch if not os.path.exists(args.directory): try: os.makedirs(args.directory) except OSError as exception: if exception.errno != errno.EEXIST: raise if not hasattr(args, "app_name"): args.app_name = "" if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) args.app_name = self.utils.extract_app_name(args.app_name) hooksObj.statsd_message_list = self.statsd_message_list hookname = "pre_gitpull" hookname_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"{0}/{1}".format(args.directory, repo_name) if os.path.isdir(path): with chdir(path): exit_code = gitObj.gitPull(branch) else: with chdir('{0}'.format(args.directory)): exit_code = gitObj.gitShallowClone(repo, branch) if exit_code != 0: raise ValueError('gitpull failed.') hooksObj.statsd_message_list = self.statsd_message_list hookname = "post_gitpull" hookname_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"The following error occurred: %s" % e, file=sys.stderr) execution_result = 'FAILURE' raise finally: try: # If the gitpull fails before going through any steps if 'function_execution_start_time' not in globals() and 'function_execution_start_time' not in locals(): function_execution_start_time = datetime.now() if 'execution_result' not in globals() and 'execution_result' not in locals(): execution_result = 'FAILURE' if 'config_name' not in globals() and 'config_name' not in locals(): config_name = "" if 'environment' not in globals() and 'environment' not in locals(): environment = "dev" if not hasattr(args, "app_name"): args.app_name = "" if 'settingObj' not in globals() and 'settingObj' not in locals(): settingObj = Settings() if 'execution_result' is 'FAILURE': self.outcome = 0 sc = self.utils.getStatsClient() if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) time_take_milliseonds = ((datetime.now() - function_execution_start_time).total_seconds() * 1000) input_metric = "roger-tools.rogeros_tools_exec_time," + "app_name=" + str(args.app_name) + ",event=gitpull" + ",identifier=" + str(self.identifier) + ",outcome=" + str(execution_result) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"The following error occurred: %s" % e, file=sys.stderr) raise
class TestDeploy(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--environment', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument('-s', '--skip-build', action="store_true", help="Flag that skips roger-build when set to true. Defaults to false.'") parser.add_argument('-M', '--incr-major', action="store_true", help="Increment major in version. Defaults to false.'") parser.add_argument('-p', '--incr-patch', action="store_true", help="Increment patch in version. Defaults to false.'") parser.add_argument('-sp', '--skip-push', action="store_true", help="Flag that skips roger push when set to true. Defaults to false.'") parser.add_argument( '-S', '--secrets-file', help="Specify an optional secrets file for deployment runtime variables.") parser.add_argument( '-d', '--directory', help="Specify an optional directory to pull out the repo. This is the working directory.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" config = {u'repo': u'roger', u'notifications': {u'username': u'Roger Deploy', u'method': u'chat.postMessage', u'channel': u'Channel ID', u'emoji': u':rocket:'}, u'apps': {u'test_app': {u'imageBase': u'test_app_base', u'name': u'test_app', u'containers': [u'container_name1', u'container_name2']}, u'test_app1': {u'framework': u'chronos', u'name': u'test_app1', u'containers': [u'container_name1', u'container_name2'], u'imageBase': u'test_app_base'}, u'grafana_test_app': {u'imageBase': u'test_app_base', u'name': u'test_app_grafana', u'containers': [u'grafana', {u'grafana1': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'0.5'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}, {u'grafana2': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}]}}, u'name': u'test-app', u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'1'}, u'stage': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'instances': u'1', u'network': u'BRIDGE'}}} roger_env = {u'default_environment': u'dev', u'registry': u'example.com:5000', u'environments': {u'prod': {u'chronos_endpoint': u'http://prod.example.com:4400', u'marathon_endpoint': u'http://prod.example.com:8080'}, u'dev': {u'chronos_endpoint': u'http://dev.example.com:4400', u'marathon_endpoint': u'http://dev.example.com:8080'}, u'stage': {u'chronos_endpoint': u'http://stage.example.com:4400', u'marathon_endpoint': u'http://stage.example.com:8080'}}} data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data def test_splitVersion(self): roger_deploy = RogerDeploy() assert roger_deploy.splitVersion("0.1.0") == (0, 1, 0) assert roger_deploy.splitVersion("2.0013") == (2, 13, 0) def test_incrementVersion(self): git_sha = "dwqjdqgwd7y12edq21" image_version_list = ['0.001', '0.2.034', '1.1.2', '1.002.1'] roger_deploy = RogerDeploy() args = self.args args.directory = "" args.secrets_file = "" args.incr_patch = True args.incr_major = True assert roger_deploy.incrementVersion( git_sha, image_version_list, args) == 'dwqjdqgwd7y12edq21/v2.0.0' assert roger_deploy.incrementVersion( git_sha, image_version_list, args) == 'dwqjdqgwd7y12edq21/v2.0.0' assert roger_deploy.incrementVersion( git_sha, image_version_list, args) == 'dwqjdqgwd7y12edq21/v2.0.0' def test_tempDirCheck(self): work_dir = "./test_dir" roger_deploy = RogerDeploy() args = self.args args.directory = "" args.skip_push = False args.secrets_file = "" temp_dir_created = True roger_deploy.removeDirTree(work_dir, args, temp_dir_created) exists = os.path.exists(os.path.abspath(work_dir)) assert exists is False os.makedirs(work_dir) exists = os.path.exists(os.path.abspath(work_dir)) assert exists is True roger_deploy.removeDirTree(work_dir, args, temp_dir_created) exists = os.path.exists(os.path.abspath(work_dir)) assert exists is False def test_roger_deploy_with_no_app(self): try: raised_exception = False settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = False args.application = '' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir except: raised_exception = True self.assertFalse(raised_exception) def test_roger_deploy_with_no_registry_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any(), any()).thenReturn("testversion/v0.1.0") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_env = appConfig.getRogerEnv(self.configs_dir) del roger_env['registry'] with self.assertRaises(ValueError): roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) def test_roger_deploy_with_no_environment_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) mockedHooks = mock(Hooks) gitObj = mock(GitUtils) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.directory = "" args.secrets_file = "" args.environment = "" args.skip_push = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir with self.assertRaises(ValueError): roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) def test_rogerDeploy(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env config = self.config data = self.data repo_name = 'roger' repo_url = 'test_url' random = 'test' when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = False args.skip_gitpull = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(settings, times=1).getConfigDir() verify(settings).getCliDir() verify(appConfig).getRogerEnv(any()) verify(appConfig, times=1).getConfig(any(), any()) verify(frameworkUtils).getFramework(data) verify(marathon).getCurrentImageVersion(any(), any(), any()) def test_rogerDeploy_with_skip_push(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env repo_name = 'roger' repo_url = 'test_url' random = 'test' config = self.config data = self.data when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = True args.skip_gitpull = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(settings, times=1).getConfigDir() verify(settings).getCliDir() verify(appConfig).getRogerEnv(any()) verify(appConfig, times=1).getConfig(any(), any()) verify(frameworkUtils).getFramework(data) verify(marathon).getCurrentImageVersion(any(), any(), any()) def test_rogerDeploy_with_skip_gitpull_false(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env repo_name = 'roger' repo_url = 'test_url' random = 'test' config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = True args.skip_gitpull = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(roger_deploy.rogerGitPullObject, times=1).main(any(), any(), any(), any(), any()) def test_rogerDeploy_with_skip_gitpull_true(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env repo_name = 'roger' repo_url = 'test_url' random = 'test' config = self.config data = self.data when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_deploy.utils).getStatsClient().thenReturn(sc) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = True args.skip_gitpull = True args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(roger_deploy.rogerGitPullObject, times=0).main(any(), any(), any(), any(), any()) def tearDown(self): pass
def setUp(self): self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir()
class TestSettings(unittest.TestCase): def setUp(self): self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() def test_getConfigDir(self): set_config_dir = '' if "ROGER_CONFIG_DIR" in os.environ: set_config_dir = os.environ.get('ROGER_CONFIG_DIR') os.environ["ROGER_CONFIG_DIR"] = self.base_dir + "/testconfigdir" config_dir = self.settingObj.getConfigDir() assert config_dir == self.base_dir + "/testconfigdir" del os.environ['ROGER_CONFIG_DIR'] try: config_dir = self.settingObj.getConfigDir() except (ValueError) as e: assert ( "Environment variable $ROGER_CONFIG_DIR is not set." in e) if set_config_dir.strip() != '': os.environ["ROGER_CONFIG_DIR"] = "{}".format(set_config_dir) def test_getComponentsDir(self): set_comp_dir = '' if "ROGER_COMPONENTS_DIR" in os.environ: set_comp_dir = os.environ.get('ROGER_COMPONENTS_DIR') os.environ["ROGER_COMPONENTS_DIR"] = self.base_dir + "/testcompdir" comp_dir = self.settingObj.getComponentsDir() assert comp_dir == self.base_dir + "/testcompdir" del os.environ['ROGER_COMPONENTS_DIR'] try: comp_dir = self.settingObj.getComponentsDir() except (ValueError) as e: assert ( "Environment variable $ROGER_COMPONENTS_DIR is not set." in e) if set_comp_dir.strip() != '': os.environ["ROGER_COMPONENTS_DIR"] = "{}".format(set_comp_dir) def test_getTemplatesDir(self): set_temp_dir = '' if "ROGER_TEMPLATES_DIR" in os.environ: set_temp_dir = os.environ.get('ROGER_TEMPLATES_DIR') os.environ["ROGER_TEMPLATES_DIR"] = self.base_dir + "/testtempldir" temp_dir = self.settingObj.getTemplatesDir() assert temp_dir == self.base_dir + "/testtempldir" del os.environ['ROGER_TEMPLATES_DIR'] try: temp_dir = self.settingObj.getTemplatesDir() except (ValueError) as e: assert ( "Environment variable $ROGER_TEMPLATES_DIR is not set." in e) if set_temp_dir.strip() != '': os.environ["ROGER_TEMPLATES_DIR"] = "{}".format(set_temp_dir) def test_getSecretsDir(self): set_sect_dir = '' if "ROGER_SECRETS_DIR" in os.environ: set_sect_dir = os.environ.get('ROGER_SECRETS_DIR') os.environ["ROGER_SECRETS_DIR"] = self.base_dir + "/testsectdir" sect_dir = self.settingObj.getSecretsDir() assert sect_dir == self.base_dir + "/testsectdir" del os.environ['ROGER_SECRETS_DIR'] try: sect_dir = self.settingObj.getSecretsDir() except (ValueError) as e: assert ( "Environment variable $ROGER_SECRETS_DIR is not set." in e) if set_sect_dir.strip() != '': os.environ["ROGER_SECRETS_DIR"] = "{}".format(set_sect_dir) def test_getCliDir(self): set_cli_dir = '' cli_dir = self.settingObj.getCliDir() assert cli_dir is not None def tearDown(self): pass
def main(self, settingObj, appObj, hooksObj, dockerUtilsObj, dockerObj, args): print(colored("******Building the Docker image now******", "grey")) try: function_execution_start_time = datetime.now() execution_result = 'SUCCESS' # Assume the execution_result to be SUCCESS unless exception occurs config_dir = settingObj.getConfigDir() root = settingObj.getCliDir() config = appObj.getConfig(config_dir, args.config_file) hooksObj.config_file = args.config_file roger_env = appObj.getRogerEnv(config_dir) config_name = "" if 'name' in config: config_name = config['name'] common_repo = config.get('repo', '') if not hasattr(args, "env"): args.env = "dev" data = appObj.getAppData(config_dir, args.config_file, args.app_name) if not data: raise ValueError("Application with name [{}] or data for it not found at {}/{}.".format( args.app_name, config_dir, args.config_file)) repo = '' if common_repo != '': repo = data.get('repo', common_repo) else: repo = data.get('repo', args.app_name) build_args = {} if 'build-args' in data: if 'environment' in data['build-args']: if args.env in data['build-args']['environment']: build_args = data['build-args']['environment'][args.env] projects = data.get('privateProjects', []) # get/update target source(s) file_exists = True file_path = '' cur_dir = '' if "PWD" in os.environ: cur_dir = os.environ.get('PWD') # This is bad code, assuming current directory and then trying to again guess, this is not rocket science # it's a f*****g file path, as simple as that. https://seomoz.atlassian.net/browse/ROGER-2405 # dockerfile location possibilities # 1. Path relative to the repo, we know repo path for cli is <checkout_dir>/<repo> # 2. Absolute path # This path comes from config file and not passed on commandline so we should not try to prefix current # working directory if the relative path is passed, don't try to guess too much. # changelog : relative path from current directory won't work for working_directory or checkout_dir # changelog : working_directory or checkout_dir should be absolute path, not backward-compatible checkout_dir = os.path.abspath(args.directory) repo_name = appObj.getRepoName(repo) # (vmahedia) todo : this should be called docker_file_dir dockerfile_rel_repo_path = data.get('path', '') file_path = os.path.join(checkout_dir, repo_name, dockerfile_rel_repo_path) if not hasattr(args, "app_name"): args.app_name = "" if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) args.app_name = self.utils.extract_app_name(args.app_name) hooksObj.statsd_message_list = self.statsd_message_list hookname = "pre_build" hookname_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(args.env) + ",user="******"{} hook failed.".format(hookname)) build_filename = 'Dockerfile' if 'build_filename' in data: build_filename = ("{0}/{1}".format(file_path, data['build_filename'])) file_exists = os.path.exists(build_filename) if not file_exists: raise ValueError("Specified build file: {} does not exist. Exiting build.".format(build_filename)) else: file_exists = os.path.exists("{0}/Dockerfile".format(file_path)) if file_exists: # (vmahedia) todo: We know what parameters are required for build command so we should not wait until # now to bailout. Config parser should have a validator for every command to see if all the Required # parameters are passed or not. Why do all this up to this point if we know we will fail on this. # RequiredParameter, below, "registry" if 'registry' not in roger_env: raise ValueError("Registry not found in roger-mesos-tools.config file.") else: self.registry = roger_env['registry'] self.tag_name = args.tag_name image = "{0}/{1}".format(roger_env['registry'], args.tag_name) try: if checkout_dir == args.directory: try: dockerObj.docker_build( dockerUtilsObj, appObj, args.directory, repo, projects, dockerfile_rel_repo_path, image, build_args, args.verbose, build_filename) except ValueError: raise ValueError("Docker build failed") else: directory = '{0}/{1}'.format(cur_dir, args.directory) try: dockerObj.docker_build( dockerUtilsObj, appObj, directory, repo, projects, dockerfile_rel_repo_path, image, build_args, args.verbose, build_filename) except ValueError: print('Docker build failed.') raise print(colored("******Successfully built Docker image******", "green")) build_message = "Image [{}]".format(image) if(args.push): print(colored("******Pushing Docker image to registry******", "grey")) exit_code = dockerUtilsObj.docker_push(image, args.verbose) if exit_code != 0: raise ValueError( 'Docker push failed.') build_message += " successfully pushed to registry [{}]*******".format(roger_env[ 'registry']) print(colored(build_message, "green")) except (IOError) as e: printException(e) raise else: print(colored("Dockerfile does not exist in dir: {}".format(file_path), "red")) hooksObj.statsd_message_list = self.statsd_message_list hookname = "post_build" hookname_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(args.env) + ",user="******"" if not hasattr(args, "env"): args.env = "dev" if not hasattr(args, "app_name"): args.app_name = "" if 'settingObj' not in globals() and 'settingObj' not in locals(): settingObj = Settings() if 'execution_result' is 'FAILURE': self.outcome = 0 sc = self.utils.getStatsClient() if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) time_take_milliseonds = ((datetime.now() - function_execution_start_time).total_seconds() * 1000) input_metric = "roger-tools.rogeros_tools_exec_time," + "app_name=" + str(args.app_name) + ",event=build" + ",identifier=" + str(self.identifier) + ",outcome=" + str(execution_result) + ",config_name=" + str(config_name) + ",env=" + str(args.env) + ",user=" + str(settingObj.getUser()) tup = (input_metric, time_take_milliseonds) self.statsd_message_list.append(tup) except (Exception) as e: printException(e) raise
class Testcontainer(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--env', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument( '--skip-push', '-s', help="Don't push. Only generate components. Defaults to false.", action="store_true") parser.add_argument('--secrets-file', '-S', help="Specify an optional secrets file for deploy runtime variables.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" with open(self.configs_dir + '/roger_single_container_var_tests.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['container-vars'] self.config = config self.roger_env = roger_env self.data = data def test_vars_single_container(self): settings = mock(Settings) appConfig = mock(AppConfig) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_push = RogerPush() roger_push.utils = mock(Utils) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn( self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn( self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn( self.base_dir + "/tests/templates") when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(self.configs_dir, "roger_single_container_var_tests.json").thenReturn(config) when(appConfig).getAppData(self.configs_dir, "roger_single_container_var_tests.json", "container-vars").thenReturn(data) args = self.args args.env = "dev" args.skip_push = True args.secrets_dir = "" args.app_name = 'container-vars' args.config_file = 'roger_single_container_var_tests.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'tests/v0.1.0' args.secrets_file = 'test' args.verbose = False roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) with open(self.base_dir + '/tests/components/dev/roger-single-container-var-tests.json') as output: output = json.load(output) var1 = output["env"]["VAR_1"] var3 = output["env"]["VAR_3"] var4 = output["env"]["VAR_4"] print ("Expected Value -> Var1 : environment_value_1") print ("Actual Value : {}".format(var1)) print ("Expected Value -> Var3 : value_3") print ("Actual Value : {}".format(var3)) assert var3 == "value_3" assert var1 == "environment_value_1" def tearDown(self): pass
class TestPush(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument( '-e', '--env', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument( '--skip-push', '-s', help="Don't push. Only generate components. Defaults to false.", action="store_true") parser.add_argument( '--secrets-file', '-S', help= "Specify an optional secrets file for deploy runtime variables.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' config = { u'repo': u'roger', u'act-as': u'test', u'notifications': { u'username': u'Roger Deploy', u'method': u'chat.postMessage', u'channel': u'Channel ID', u'emoji': u':rocket:' }, u'apps': { u'test_app': { u'imageBase': u'test_app_base', u'name': u'test_app', u'containers': [u'container_name1', u'container_name2'] }, u'test_app1': { u'vars': { u'global': { u'env_value1': u'12', u'env_value2': u'16' }, u'environment': { u'test': { u'env_value1': u'20', u'env_value2': u'24' } } }, u'framework': u'chronos', u'name': u'test_app1', u'containers': [u'container_name1', u'container_name2'], u'imageBase': u'test_app_base' }, u'grafana_test_app': { u'imageBase': u'test_app_base', u'name': u'test_app_grafana', u'containers': [ u'grafana', { u'grafana1': { u'vars': { u'environment': { u'prod': { u'mem': u'2048', u'cpus': u'2' }, u'dev': { u'mem': u'512', u'cpus': u'0.5' }, u'test': { u'env_value1': u'64', u'env_value2': u'128' } }, u'global': { u'mem': u'128', u'cpus': u'0.1', u'env_value1': u'30', u'env_value2': u'54' } } } }, { u'grafana2': { u'vars': { u'environment': { u'prod': { u'mem': u'2048', u'cpus': u'2' }, u'dev': { u'mem': u'1024', u'cpus': u'1' } }, u'global': { u'mem': u'128', u'cpus': u'0.1' } } } } ] } }, u'name': u'test-app', u'vars': { u'environment': { u'prod': { u'mem': u'2048', u'cpus': u'2' }, u'test': { u'env_value1': u'4', u'env_value2': u'8' }, u'dev': { u'mem': u'512', u'cpus': u'1' }, u'stage': { u'mem': u'1024', u'cpus': u'1' } }, u'global': { u'instances': u'1', u'network': u'BRIDGE', u'env_value1': u'3', u'env_value2': u'3' } } } with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data test_config = config test_data = test_config['apps']['grafana_test_app'] self.test_config = test_config self.test_data = test_data template = Template( '{ "env": { "ENV_VAR1": "{{ env_value1 }}", "ENV_VAR2": "{{ env_value2 }}" }}' ) self.template = template self.additional_vars = {} def test_template_render_for_extra_variables(self): roger_push = RogerPush() app_data = self.config['apps']['grafana_test_app'] container = app_data['containers'][1]['grafana1'] additional_vars = self.additional_vars additional_vars['env_value1'] = "100" additional_vars['env_value2'] = "200" output = roger_push.renderTemplate(self.template, "test", "test_image", app_data, self.config, container, "grafana1", additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '100' assert result['env']['ENV_VAR2'] == '200' def test_template_render_for_config_level_variables(self): roger_push = RogerPush() app_data = self.config['apps']['test_app'] container = "container_name1" output = roger_push.renderTemplate(self.template, "test", "test_image", app_data, self.config, container, "container_name1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '4' assert result['env']['ENV_VAR2'] == '8' def test_template_render_for_app_level_variables(self): roger_push = RogerPush() app_data = self.config['apps']['test_app1'] container = "container_name1" # Passing environment that doesn't exist output = roger_push.renderTemplate(self.template, "non_existing_env", "test_image", app_data, self.config, container, "container_name1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '12' assert result['env']['ENV_VAR2'] == '16' # Existing environment output = roger_push.renderTemplate(self.template, "test", "test_image", app_data, self.config, container, "container_name1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '20' assert result['env']['ENV_VAR2'] == '24' def test_template_render_for_container_level_variables(self): roger_push = RogerPush() app_data = self.config['apps']['grafana_test_app'] container = "grafana" # Passing environment that doesn't exist output = roger_push.renderTemplate(self.template, "non_existing_env", "test_image", app_data, self.config, container, "grafana", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '3' assert result['env']['ENV_VAR2'] == '3' # Existing environment output = roger_push.renderTemplate(self.template, "test", "test_image", app_data, self.config, container, "grafana", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '4' assert result['env']['ENV_VAR2'] == '8' container = app_data['containers'][1]['grafana1'] output = roger_push.renderTemplate(self.template, "non_existing_env", "test_image", app_data, self.config, container, "grafana1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '30' assert result['env']['ENV_VAR2'] == '54' output = roger_push.renderTemplate(self.template, "test", "test_image", app_data, self.config, container, "grafana1", self.additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '64' assert result['env']['ENV_VAR2'] == '128' def test_roger_push_grafana_test_app(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn("Response [200]", any()) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) with open(self.base_dir + '/tests/templates/test-app-grafana.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" verify(settings).getConfigDir() verify(settings).getComponentsDir() verify(settings).getTemplatesDir() verify(settings).getSecretsDir() verify(frameworkUtils).getFramework(data) def test_container_resolution(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.test_config data = self.test_data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).getName().thenReturn('Marathon') when(marathon).put(any(), any(), any()).thenReturn("Response [200]") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.directory = self.base_dir + '/tests/testrepo' args.config_file = 'test.json' args.image_name = 'grafana/grafana:2.1.3' roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) with open(self.base_dir + '/tests/templates/test-app-grafana.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" assert output['cpus'] == 2 assert output['mem'] == 1024 assert output['uris'] == ["abc", "xyz", "$ENV_VAR"] with open(self.base_dir + '/tests/templates/test-app-grafana1.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" assert output['cpus'] == 0.5 assert output['mem'] == 512 with open(self.base_dir + '/tests/templates/test-app-grafana2.json') as output: output = json.load(output) assert output['container']['docker'][ 'image'] == "grafana/grafana:2.1.3" assert output['cpus'] == 1 assert output['mem'] == 1024 def test_roger_push_with_no_app_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.app_name = '' args.config_file = 'test.json' args.env = 'some_test_env' with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_no_registry_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' config_dir = settings.getConfigDir() roger_env = appConfig.getRogerEnv(config_dir) # Remove registry key from dictionary del roger_env['registry'] with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_no_environment_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args # Set environment variable as None args.env = '' args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_unresolved_jinja_variable_fails(self): with open(self.configs_dir + '/roger_push_unresolved_jinja.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['container-vars'] self.config = config self.roger_env = roger_env self.data = data settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(roger_push.utils).get_version().thenReturn(any()) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig( self.configs_dir, "roger_push_unresolved_jinja.json").thenReturn(config) when(appConfig).getAppData(self.configs_dir, "roger_push_unresolved_jinja.json", "container-vars").thenReturn(data) args = self.args args.env = "dev" args.skip_push = False args.force_push = False args.secrets_dir = "" args.secrets_file = "" args.app_name = 'container-vars' args.config_file = 'roger_push_unresolved_jinja.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'tests/v0.1.0' roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(frameworkUtils, times=0).put(any(), any(), any(), any()) def test_roger_push_calls_prepush_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) frameworkUtils = mock(FrameworkUtils) roger_env = self.roger_env appdata = self.data config = self.config sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(any()).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata["hooks"] = dict([("pre_push", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.env = 'dev' args.image_name = 'tests/v0.1.0' args.directory = '/tmp' args.secrets_file = "" args.skip_push = True return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(mockedHooks).run_hook("pre_push", any(), any(), any()) def test_roger_push_calls_postpush_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) frameworkUtils = mock(FrameworkUtils) roger_env = self.roger_env appdata = self.data config = self.config sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(any()).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata["hooks"] = dict([("post_push", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.env = 'dev' args.image_name = 'tests/v0.1.0' args.directory = '/tmp' args.secrets_file = "" args.skip_push = True return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(mockedHooks).run_hook("post_push", any(), any(), any()) def test_roger_push_verify_default_env_use(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config frameworkUtils = mock(FrameworkUtils) when(settings).getConfigDir().thenReturn(self.configs_dir) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = None args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' roger_env = appConfig.getRogerEnv(self.configs_dir) roger_env["default_environment"] = "test_env" with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_incorrect_container_name(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config appdata = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") frameworkUtils = mock(FrameworkUtils) when(marathon).getName().thenReturn('Marathon') when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app:test' args.config_file = 'test.json' with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_with_correct_container_name(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) frameworkUtils = mock(FrameworkUtils) roger_env = self.roger_env appdata = self.data config = self.config sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(any()).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) appdata["hooks"] = dict([("post_push", "some command")]) when(appConfig).getAppData(any(), any(), any()).thenReturn(appdata) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app:grafana' args.config_file = 'test.json' args.image_name = 'grafana/grafana:2.1.3' roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(frameworkUtils).getFramework(any()) def test_roger_push_env_from_ROGER_ENV_VAR(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config frameworkUtils = mock(FrameworkUtils) when(settings).getConfigDir().thenReturn(self.configs_dir) when(mockedHooks).run_hook(any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) args = self.args args.env = None args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' roger_env = appConfig.getRogerEnv(self.configs_dir) roger_env["default_environment"] = None # Setting ROGER_ENV to specific value os.environ["ROGER_ENV"] = "test_env" with self.assertRaises(ValueError): roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_push_happens_with_validation_error_when_force_push_set(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data when(marathon).getName().thenReturn('Marathon') when(marathon).put(any(), any(), any(), any(), any()).thenReturn(["Response [200]", any()]) when(marathon).runDeploymentChecks(any(), any()).thenReturn(True) frameworkUtils = mock(FrameworkUtils) frameworkUtils = mock(FrameworkUtils) sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(roger_push.utils).modify_task_id(any()).thenReturn([any()]) when(roger_push.utils).get_version().thenReturn(any()) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = False args.force_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) def test_roger_push_skip_push_set(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn(["Response [200]", any()]) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(frameworkUtils, times=0).runDeploymentChecks(any(), any()) def test_push_fails_with_validation_error(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(roger_push.utils).modify_task_id(any()).thenReturn([any()]) when(roger_push.utils).get_version().thenReturn(any()) frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(marathon).put(any(), any(), any(), any(), any()).thenReturn(["Response [200]", any()]) when(marathon).runDeploymentChecks(any(), any()).thenReturn(True) when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) when(appConfig).getRogerEnv(self.configs_dir).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = False args.force_push = False args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' return_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) verify(frameworkUtils, times=0).put(any(), any(), any(), any()) def test_roger_push_secrets_replaced(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_push = RogerPush() roger_push.utils = mock(Utils) marathon = mock(Marathon) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data sc = mock(StatsClient) when(sc).timing(any(), any()).thenReturn(any()) when(roger_push.utils).getStatsClient().thenReturn(sc) when(roger_push.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_push.utils).extract_app_name(any()).thenReturn("test") when(marathon).put(any(), any(), any()).thenReturn("Response [200]") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(marathon).getName().thenReturn('Marathon') when(settings).getComponentsDir().thenReturn(self.base_dir + "/tests/components") when(settings).getSecretsDir().thenReturn(self.base_dir + "/tests/secrets") when(settings).getTemplatesDir().thenReturn(self.base_dir + "/tests/templates") when(settings).getConfigDir().thenReturn(self.configs_dir) when(settings).getCliDir().thenReturn(self.base_dir) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(mockedHooks).run_hook(any(), any(), any(), any()).thenReturn(0) args = self.args args.env = "dev" args.secrets_file = "" args.skip_push = True args.app_name = 'grafana_test_app' args.config_file = 'test.json' args.directory = self.base_dir + '/tests/testrepo' args.image_name = 'grafana/grafana:2.1.3' exit_code = roger_push.main(settings, appConfig, frameworkUtils, mockedHooks, args) file_path = ("{0}/{1}/{2}".format(self.components_dir, args.env, args.config_file)) assert (os.path.isfile(file_path) is not True) def test_secret_vars_replacement_for_no_secrets_file(self): args = self.args args.env = "test" args.secrets_file = "" args.app_name = 'test_app' args.image_name = 'test_image' secrets_dir = self.base_dir + "/tests/secrets" roger_push = RogerPush() app_data = self.config['apps'][args.app_name] container = "container1" additional_vars = self.additional_vars extra_vars = {} extra_vars['env_value1'] = "100" extra_vars['env_value2'] = "200" additional_vars.update(extra_vars) secret_vars = roger_push.loadSecrets(secrets_dir, args.secrets_file, args, args.env) additional_vars.update(secret_vars) output = roger_push.renderTemplate(self.template, args.env, args.image_name, app_data, self.config, container, "container1", additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == '100' assert result['env']['ENV_VAR2'] == '200' def test_secret_vars_replacement_with_secrets_file(self): args = self.args args.env = "test" args.secrets_file = "test_app-container1.json" args.app_name = 'test_app' args.image_name = 'test_image' secrets_dir = self.base_dir + "/tests/secrets" roger_push = RogerPush() app_data = self.config['apps'][args.app_name] container = "container1" additional_vars = self.additional_vars extra_vars = {} extra_vars['env_value1'] = "100" extra_vars['env_value2'] = "200" additional_vars.update(extra_vars) secret_vars = roger_push.loadSecrets(secrets_dir, args.secrets_file, args, args.env) print(secret_vars) additional_vars.update(secret_vars) output = roger_push.renderTemplate(self.template, args.env, args.image_name, app_data, self.config, container, "container1", additional_vars) result = json.loads(output) assert result['env']['ENV_VAR1'] == 'test_value1' assert result['env']['ENV_VAR2'] == 'test_value2' def tearDown(self): pass
class TestDeploy(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('-e', '--environment', metavar='env', help="Environment to deploy to. example: 'dev' or 'stage'") parser.add_argument('-s', '--skip-build', action="store_true", help="Flag that skips roger-build when set to true. Defaults to false.'") parser.add_argument('-M', '--incr-major', action="store_true", help="Increment major in version. Defaults to false.'") parser.add_argument('-p', '--incr-patch', action="store_true", help="Increment patch in version. Defaults to false.'") parser.add_argument('-sp', '--skip-push', action="store_true", help="Flag that skips roger push when set to true. Defaults to false.'") parser.add_argument( '-S', '--secrets-file', help="Specify an optional secrets file for deployment runtime variables.") parser.add_argument( '-d', '--directory', help="Specify an optional directory to pull out the repo. This is the working directory.") self.parser = parser self.args = parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" config = {u'repo': u'roger', u'notifications': {u'username': u'Roger Deploy', u'method': u'chat.postMessage', u'channel': u'Channel ID', u'emoji': u':rocket:'}, u'apps': {u'test_app': {u'imageBase': u'test_app_base', u'name': u'test_app', u'containers': [u'container_name1', u'container_name2']}, u'test_app1': {u'framework': u'chronos', u'name': u'test_app1', u'containers': [u'container_name1', u'container_name2'], u'imageBase': u'test_app_base'}, u'grafana_test_app': {u'imageBase': u'test_app_base', u'name': u'test_app_grafana', u'containers': [u'grafana', {u'grafana1': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'0.5'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}, {u'grafana2': {u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'mem': u'128', u'cpus': u'0.1'}}}}]}}, u'name': u'test-app', u'vars': {u'environment': {u'prod': {u'mem': u'2048', u'cpus': u'2'}, u'dev': {u'mem': u'512', u'cpus': u'1'}, u'stage': {u'mem': u'1024', u'cpus': u'1'}}, u'global': {u'instances': u'1', u'network': u'BRIDGE'}}} roger_env = {u'default_environment': u'dev', u'registry': u'example.com:5000', u'environments': {u'prod': {u'chronos_endpoint': u'http://prod.example.com:4400', u'marathon_endpoint': u'http://prod.example.com:8080'}, u'dev': {u'chronos_endpoint': u'http://dev.example.com:4400', u'marathon_endpoint': u'http://dev.example.com:8080'}, u'stage': {u'chronos_endpoint': u'http://stage.example.com:4400', u'marathon_endpoint': u'http://stage.example.com:8080'}}} data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data def test_splitVersion(self): roger_deploy = RogerDeploy() assert roger_deploy.splitVersion("0.1.0") == (0, 1, 0) assert roger_deploy.splitVersion("2.0013") == (2, 13, 0) def test_incrementVersion(self): git_sha = "dwqjdqgwd7y12edq21" image_version_list = ['0.001', '0.2.034', '1.1.2', '1.002.1'] roger_deploy = RogerDeploy() args = self.args args.directory = "" args.secrets_file = "" args.incr_patch = True args.incr_major = True assert roger_deploy.incrementVersion( git_sha, image_version_list, args) == 'dwqjdqgwd7y12edq21/v2.0.0' assert roger_deploy.incrementVersion( git_sha, image_version_list, args) == 'dwqjdqgwd7y12edq21/v2.0.0' assert roger_deploy.incrementVersion( git_sha, image_version_list, args) == 'dwqjdqgwd7y12edq21/v2.0.0' def test_tempDirCheck(self): work_dir = "./test_dir" roger_deploy = RogerDeploy() args = self.args args.directory = "" args.skip_push = False args.secrets_file = "" temp_dir_created = True roger_deploy.removeDirTree(work_dir, args, temp_dir_created) exists = os.path.exists(os.path.abspath(work_dir)) assert exists is False os.makedirs(work_dir) exists = os.path.exists(os.path.abspath(work_dir)) assert exists is True roger_deploy.removeDirTree(work_dir, args, temp_dir_created) exists = os.path.exists(os.path.abspath(work_dir)) assert exists is False def test_roger_deploy_with_no_app(self): try: raised_exception = False settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env config = self.config data = self.data when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = False args.application = '' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir except: raised_exception = True self.assertFalse(raised_exception) def test_roger_deploy_with_no_registry_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any(), any()).thenReturn("testversion/v0.1.0") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_env = appConfig.getRogerEnv(self.configs_dir) del roger_env['registry'] with self.assertRaises(ValueError): roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) def test_roger_deploy_with_no_environment_fails(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) mockedHooks = mock(Hooks) gitObj = mock(GitUtils) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env config = self.config data = self.data when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) args = self.args args.directory = "" args.secrets_file = "" args.environment = "" args.skip_push = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None args.verbose = False os.environ["ROGER_CONFIG_DIR"] = self.configs_dir with self.assertRaises(ValueError): roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) def test_rogerDeploy(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env config = self.config data = self.data repo_name = 'roger' repo_url = 'test_url' random = 'test' when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = False args.skip_gitpull = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.verbose = False args.branch = None os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(settings, times=1).getConfigDir() verify(settings).getCliDir() verify(appConfig).getRogerEnv(any()) verify(appConfig, times=1).getConfig(any(), any()) verify(frameworkUtils).getFramework(data) verify(marathon).getCurrentImageVersion(any(), any(), any()) def test_rogerDeploy_with_skip_push(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env repo_name = 'roger' repo_url = 'test_url' random = 'test' config = self.config data = self.data when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = True args.skip_gitpull = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None args.verbose = False os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(settings, times=1).getConfigDir() verify(settings).getCliDir() verify(appConfig).getRogerEnv(any()) verify(appConfig, times=1).getConfig(any(), any()) verify(frameworkUtils).getFramework(data) verify(marathon).getCurrentImageVersion(any(), any(), any()) def test_rogerDeploy_with_skip_gitpull_false(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env repo_name = 'roger' repo_url = 'test_url' random = 'test' config = self.config data = self.data when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = True args.skip_gitpull = False args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None args.verbose = False os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(roger_deploy.rogerGitPullObject, times=1).main(any(), any(), any(), any(), any()) def test_rogerDeploy_with_skip_gitpull_true(self): settings = mock(Settings) appConfig = mock(AppConfig) roger_deploy = RogerDeploy() marathon = mock(Marathon) gitObj = mock(GitUtils) mockedHooks = mock(Hooks) roger_deploy.rogerGitPullObject = mock(RogerGitPull) roger_deploy.rogerPushObject = mock(RogerPush) roger_deploy.rogerBuildObject = mock(RogerBuild) roger_deploy.dockerUtilsObject = mock(DockerUtils) roger_deploy.dockerObject = mock(Docker) roger_deploy.utils = mock(Utils) roger_env = self.roger_env repo_name = 'roger' repo_url = 'test_url' random = 'test' config = self.config data = self.data when(marathon).getCurrentImageVersion( any(), any(), any()).thenReturn("testversion/v0.1.0") when(marathon).getName().thenReturn('Marathon') frameworkUtils = mock(FrameworkUtils) when(roger_deploy.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_deploy.utils).extract_app_name(any()).thenReturn("test") when(frameworkUtils).getFramework(data).thenReturn(marathon) when(settings).getConfigDir().thenReturn(any()) when(settings).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn('test_user') when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(gitObj).gitPull(any()).thenReturn(0) when(gitObj).gitShallowClone(any(), any()).thenReturn(0) when(gitObj).gitClone(any(), any()).thenReturn(0) when(gitObj).getGitSha(any(), any(), any()).thenReturn(random) when(roger_deploy.rogerGitPullObject).main(any(), any(), any(), any(), any()).thenReturn(0) when(roger_deploy.rogerPushObject).main(any(), any(), any(), any(), any()).thenReturn(0) args = self.args args.directory = "" args.secrets_file = "" args.environment = "dev" args.skip_push = True args.skip_gitpull = True args.application = 'grafana_test_app' args.config_file = 'test.json' args.skip_build = True args.branch = None args.verbose = False os.environ["ROGER_CONFIG_DIR"] = self.configs_dir roger_deploy.main(settings, appConfig, frameworkUtils, gitObj, mockedHooks, args) verify(roger_deploy.rogerGitPullObject, times=0).main(any(), any(), any(), any(), any()) def tearDown(self): pass
def main(self, settings, appConfig, frameworkObject, hooksObj, args): print(colored("******Deploying application to framework******", "grey")) try: validation_failed = False settingObj = settings appObj = appConfig frameworkUtils = frameworkObject config_dir = settingObj.getConfigDir() hooksObj.config_file = args.config_file cur_file_path = os.path.dirname(os.path.realpath(__file__)) config = appObj.getConfig(config_dir, args.config_file) config_name = "" act_as_user = "" if 'name' in config: config_name = config['name'] if 'act-as' in config: act_as_user = config['act-as'] roger_env = appObj.getRogerEnv(config_dir) if not hasattr(args, "app_name"): args.app_name = "" if 'registry' not in roger_env.keys(): raise ValueError("Registry not found in roger-mesos-tools.config file.") else: self.registry = roger_env['registry'] if hasattr(args, "image_name"): self.image_name = args.image_name environment = roger_env.get('default_environment', '') if args.env is None: if "ROGER_ENV" in os.environ: env_var = os.environ.get('ROGER_ENV') if env_var.strip() == '': print(colored("WARNING - Environment variable $ROGER_ENV is not set. Using the default set from roger-mesos-tools.config file", "yellow")) else: if args.verbose: print(colored("Using value {} from environment variable $ROGER_ENV".format(env_var), "grey")) environment = env_var else: environment = args.env # ---------------------------------------------- if environment not in roger_env['environments']: raise ValueError("Environment not found in roger-mesos-tools.config file.") # ---------------------------------------------- # GetEnvironmentConfig(environment) # ---------------------------------------------- environmentObj = roger_env['environments'][environment] common_repo = config.get('repo', '') # ---------------------------------------------- # GetContainersForApp(app) # ---------------------------------------------- app_name = args.app_name container_list = [] # todo (vmahedia): What does ':' signify? Put explanation. if ':' in app_name: tokens = app_name.split(':') app_name = tokens[0] # todo (vmahedia): it's container list - need to explain syntax if ',' in tokens[1]: container_list = tokens[1].split(',') else: container_list.append(tokens[1]) # ---------------------------------------------- data = appObj.getAppData(config_dir, args.config_file, app_name) if not data: raise ValueError("Application with name [{}] or data for it not found at {}/{}.".format( app_name, config_dir, args.config_file)) configured_container_list = [] for task in data['containers']: if type(task) == dict: configured_container_list.append(task.keys()[0]) else: configured_container_list.append(task) if not set(container_list) <= set(configured_container_list): raise ValueError("List of containers [{}] passed do not match list of acceptable containers: [{}]".format( container_list, configured_container_list)) frameworkObj = frameworkUtils.getFramework(data) framework = frameworkObj.getName() repo = '' if common_repo != '': repo = data.get('repo', common_repo) else: repo = data.get('repo', app_name) comp_dir = settingObj.getComponentsDir() templ_dir = settingObj.getTemplatesDir() secrets_dir = settingObj.getSecretsDir() # Create comp_dir if it doesn't exist if not os.path.isdir(comp_dir): os.makedirs(comp_dir) if not container_list: data_containers = data['containers'] else: data_containers = container_list failed_container_dict = {} # (vmahedia) upto this point it's all getting and checking the # configuration parameters template = '' # Required for when work_dir,component_dir,template_dir or # secret_env_dir is something like '.' or './temp" os.chdir(cur_file_path) app_path = '' if 'template_path' in data: app_path = self.repo_relative_path(appObj, args, repo, data['template_path']) else: app_path = templ_dir extra_vars = {} if 'extra_variables_path' in data: ev_path = self.repo_relative_path(appObj, args, repo, data['extra_variables_path']) with open(ev_path) as f: extra_vars = yaml.load(f) if ev_path.lower( ).endswith('.yml') else json.load(f) if not app_path.endswith('/'): app_path = app_path + '/' if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) args.app_name = self.utils.extract_app_name(args.app_name) hooksObj.statsd_message_list = self.statsd_message_list hookname = "pre_push" hook_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"{} hook failed.".format(hookname)) # ---------------------------------------------- # (vmahedia) Figure out what the hell this loop does # and name it appropriately # it seems first part is just finding a template and Rendering # it against the given config, checking to see if there are errors # ---------------------------------------------- # (vmahedia) Meat starts from here, probably. for container in data_containers: container_name = self.getContainerName(container) containerConfig = "{0}-{1}.json".format(config['name'], container_name) env = Environment(loader = FileSystemLoader("{}".format(app_path)), undefined = StrictUndefined) template_with_path = "[{}{}]".format(app_path, containerConfig) try: template = env.get_template(containerConfig) except exceptions.TemplateNotFound as e: raise ValueError("The template file {} does not exist".format(template_with_path)) except Exception as e: raise ValueError("Error while reading template from {} - {}".format(template_with_path, e)) additional_vars = {} # (vmahedia)variables likes this should be at least visible within one # scroll up or down, move this code to near to context # Why are we getting the secrets everytime, this requires the file to be # present additional_vars.update(extra_vars) secret_vars = self.loadSecrets(secrets_dir, containerConfig, args, environment) additional_vars.update(secret_vars) image_path = "{0}/{1}".format( roger_env['registry'], args.image_name) print("Rendering content from template {} for environment [{}]".format( template_with_path, environment)) try: output = self.renderTemplate(template, environment, image_path, data, config, container, container_name, additional_vars) except exceptions.UndefinedError as e: error_str = "The following Undefined Jinja variable error occurred. %s.\n" % e print(colored(error_str, "red"), file=sys.stderr) failed_container_dict[container_name] = error_str # we are going to fail even if one of the container config is not valid but we will # still go through the loop and collect all the errors before we bail out validation_failed = True pass # ---------------------------------------------- # it seems the checks above can finish independent of the # following code, decouple this two parts, later when the code # is well understood # ---------------------------------------------- # Adding check to see if all jinja variables git resolved fot # the container if container_name not in failed_container_dict: # Adding check so that not all apps try to mergeSecrets try: outputObj = json.loads(output) except Exception as e: raise ValueError("Error while loading json from {} - {}".format(template_with_path, e)) if '\"SECRET\"' in output: output = self.mergeSecrets(output, self.loadSecrets( secrets_dir, containerConfig, args, environment)) if output != "StandardError": try: comp_exists = os.path.exists("{0}".format(comp_dir)) if comp_exists is False: os.makedirs("{0}".format(comp_dir)) comp_env_exists = os.path.exists( "{0}/{1}".format(comp_dir, environment)) if comp_env_exists is False: os.makedirs( "{0}/{1}".format(comp_dir, environment)) except Exception as e: logging.error(traceback.format_exc()) # (vmahedia) Should we write out the files even though there is an error with one of the # containers. Although maybe users would want to see some output with open("{0}/{1}/{2}".format(comp_dir, environment, containerConfig), 'wb') as fh: fh.write(output) else: raise ValueError("Error while loading secrets to render template file variables") # Notify container error messages # let failed_container_dict just be for now, but report all the errors if validation_failed: raise Exception("Unable to render Jinja template") deployment_check_failed = False # fail if the deployment check fails for container in data_containers: container_name = self.getContainerName(container) containerConfig = "{0}-{1}.json".format(config['name'], container_name) config_file_path = "{0}/{1}/{2}".format(comp_dir, environment, containerConfig) result = frameworkObj.runDeploymentChecks(config_file_path, environment) if not result: # need to give more indication about what can they do to fix this and what exactly failed # in the deployment check function, we should print an error in that function as well print(colored("Deployment checks failed for container - {}".format(framework, container)), "red") deployment_check_failed = True if deployment_check_failed: raise Exception("Deployment Check failed for one or more containers, check logs for more info!") if args.skip_push: print(colored("Skipping push to {} framework. The rendered config file(s) are under {}/{}/".format( framework, colored(comp_dir, "cyan"), colored(environment, "cyan")), "yellow")) else: # push to roger framework if 'owner' in config: frameworkObj.act_as_user = config['owner'] tools_version_value = self.utils.get_version() image_name = self.registry + "/" + args.image_name image_tag_value = urllib.quote("'" + image_name + "'") for container in data_containers: try: function_execution_start_time = datetime.now() # Assume SUCCESS unless exception execution_result = 'SUCCESS' sc = self.utils.getStatsClient() except (Exception) as e: raise ValueError("{} Error : {}".format(getDebugInfo(), e)) try: # this is where actual push is happening # we only push if forced, in case of failures # in deployment checks # # (vmahedia) todo: # list down scenarios in which this features # will be useful resp, task_id = frameworkObj.put(config_file_path, environmentObj, container_name, environment, act_as_user) container_task_id = self.utils.modify_task_id(task_id) self.task_id.extend(container_task_id) if hasattr(resp, "status_code"): status_code = resp.status_code except (Exception) as e: print("ERROR - : %s" % e, file=sys.stderr) execution_result = 'FAILURE' raise finally: try: if 'function_execution_start_time' not in globals() and \ 'function_execution_start_time' not in locals(): function_execution_start_time = datetime.now() if 'execution_result' not in globals() and \ 'execution_result' not in locals(): execution_result = 'FAILURE' if 'config_name' not in globals() and \ 'config_name' not in locals(): config_name = "" if 'environment' not in globals() and \ 'environment' not in locals(): environment = "dev" if 'container_name' not in globals() and \ 'container_name' not in locals(): container_name = "" if 'status_code' not in globals() and \ 'status_code' not in locals(): status_code = "500" if not hasattr(args, "app_name"): args.app_name = "" if 'settingObj' not in globals() and \ 'settingObj' not in locals(): settingObj = Settings() if 'container_task_id' not in globals() and 'container_task_id' not in locals(): container_task_id = [] if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) if not str(status_code).startswith("20"): execution_result = 'FAILURE' self.outcome = 0 time_taken = (datetime.now() - function_execution_start_time).total_seconds() for task_id in container_task_id: input_metric = "roger-tools.rogeros_tools_exec_time" + \ ",app_name=" + str(args.app_name) + \ ",event=push" + \ ",container_name=" + str(container_name) + \ ",identifier=" + str(self.identifier) + \ ",outcome=" + str(execution_result) + \ ",response_code=" + str(status_code) + \ ",config_name=" + str(config_name) + \ ",env=" + str(environment) + \ ",user="******"20"): metric = input_metric.replace("rogeros_tools_exec_time", "rogeros_events") metric = metric + ",source=tools" + ",task_id=" + task_id self.statsd_counter_logging(metric) except (Exception) as e: printException(e) raise hooksObj.statsd_message_list = self.statsd_message_list hookname = "post_push" hook_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + \ ",app_name=" + str(args.app_name) + \ ",identifier=" + str(self.identifier) + \ ",config_name=" + str(config_name) + \ ",env=" + str(environment) + \ ",user="******"{} hook failed.".format(hookname)) print(colored("******Done with the PUSH step******", "green")) except (Exception) as e: raise ValueError("ERROR - {}".format(e))
def setUp(self): self.appObj = AppConfig() self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs"
class TestBuild(unittest.TestCase): def setUp(self): parser = argparse.ArgumentParser(description='Args for test') parser.add_argument('app_name', metavar='app_name', help="application to build. Example: 'agora'.") parser.add_argument('env', metavar='env', help="environment. Example: 'test'.") parser.add_argument('directory', metavar='directory', help="working directory. Example: '/home/vagrant/work_dir'.") parser.add_argument('tag_name', metavar='tag_name', help="tag for the built image. Example: 'roger-collectd:0.20'.") parser.add_argument('config_file', metavar='config_file', help="configuration file to use. Example: 'content.json'.") parser.add_argument( '--push', '-p', help="Also push to registry. Defaults to false.", action="store_true") self.parser = parser self.args = self.parser self.settingObj = Settings() self.base_dir = self.settingObj.getCliDir() self.configs_dir = self.base_dir + "/tests/configs" self.components_dir = self.base_dir + '/tests/components/dev' with open(self.configs_dir + '/app.json') as config: config = json.load(config) with open(self.configs_dir + '/roger-mesos-tools.config') as roger: roger_env = yaml.load(roger) data = config['apps']['grafana_test_app'] self.config = config self.roger_env = roger_env self.data = data def test_roger_build(self): try: settings = mock(Settings) appConfig = mock(AppConfig) dockerUtilsObj = mock(DockerUtils) dockerObj = mock(Docker) roger_build = RogerBuild() roger_build.utils = mock(Utils) mockedHooks = mock(Hooks) roger_env = self.roger_env config = self.config data = self.data repo_name = 'test' repo_url = 'test.com' raised_exception = False when(roger_build.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_build.utils).extract_app_name(any()).thenReturn(any()) when(settings, strict=False).getConfigDir().thenReturn(any()) when(settings, strict=False).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks, strict=False).run_hook(any(), any(), any(), any()).thenReturn(0) args = self.args # Setting app_name as empty args.app_name = '' args.env = 'test' args.config_file = 'app.json' args.directory = self.base_dir # with self.assertRaises(ValueError): roger_build.main(settings, appConfig, mockedHooks, dockerUtilsObj, dockerObj, args) except: raised_exception = True self.assertFalse(raised_exception) def test_roger_build_calls_prebuild_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) dockerUtilsObj = mock(DockerUtils) dockerObj = mock(Docker) roger_build = RogerBuild() roger_build.utils = mock(Utils) mockedHooks = mock(Hooks) roger_env = {} roger_env["registry"] = "any registry" appdata = {} appdata["hooks"] = dict([("pre_build", "some command")]) config = self.config args = self.args args.config_file = 'any.json' args.app_name = 'any app' args.env = 'test' args.directory = '/tmp' data = self.data repo_name = 'test' repo_url = 'test.com' when(roger_build.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_build.utils).extract_app_name(any()).thenReturn("any app") when(settings, strict=False).getConfigDir().thenReturn(any()) when(settings, strict=False).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) return_code = roger_build.main( settings, appConfig, mockedHooks, dockerUtilsObj, dockerObj, args) verify(mockedHooks).run_hook("pre_build", any(), any(), any()) def test_roger_build_calls_postbuild_hook_when_present(self): settings = mock(Settings) appConfig = mock(AppConfig) dockerUtilsObj = mock(DockerUtils) dockerObj = mock(Docker) roger_build = RogerBuild() roger_build.utils = mock(Utils) mockedHooks = mock(Hooks) roger_env = {} roger_env["registry"] = "any registry" appdata = {} appdata["hooks"] = dict([("post_build", "some command")]) config = self.config args = self.args args.app_name = 'any app' args.env = 'test' args.directory = '/tmp' args.config_file = 'any.json' data = self.data repo_name = 'test' repo_url = 'test.com' when(roger_build.utils).get_identifier(any(), any(), any()).thenReturn(any()) when(roger_build.utils).extract_app_name(any()).thenReturn("any app") when(settings, strict=False).getConfigDir().thenReturn(any()) when(settings, strict=False).getCliDir().thenReturn(any()) when(settings).getUser().thenReturn(any()) when(appConfig).getRogerEnv(any()).thenReturn(roger_env) when(appConfig).getConfig(any(), any()).thenReturn(config) when(appConfig).getAppData(any(), any(), any()).thenReturn(data) when(appConfig).getRepoUrl(any()).thenReturn(repo_name) when(appConfig).getRepoName(any()).thenReturn(repo_name) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) when(mockedHooks).run_hook(any(), any(), any(), any(), any(), any()).thenReturn(0) return_code = roger_build.main( settings, appConfig, mockedHooks, dockerUtilsObj, dockerObj, args) verify(mockedHooks).run_hook("post_build", any(), any(), any()) def tearDown(self): pass
def main(self, settings, appConfig, gitObject, hooksObj, args): print(colored("******Executing GIT PULL of application repo******", "grey")) try: function_execution_start_time = datetime.now() execution_result = 'SUCCESS' # Assume the execution_result to be SUCCESS unless exception occurs environment = "dev" if hasattr(args, "environment"): environment = args.environment settingObj = settings appObj = appConfig gitObj = gitObject config_dir = settingObj.getConfigDir() hooksObj.config_file = args.config_file config = appObj.getConfig(config_dir, args.config_file) config_name = "" if 'name' in config: config_name = config['name'] common_repo = config.get('repo', '') data = appObj.getAppData(config_dir, args.config_file, args.app_name) if not data: raise ValueError("Application with name [{}] or data for it not found at {}/{}.".format( args.app_name, config_dir, args.config_file)) repo = '' if common_repo != '': repo = data.get('repo', common_repo) else: repo = data.get('repo', args.app_name) branch = "master" # master by default if args.branch is not None: branch = args.branch if not os.path.exists(args.directory): try: os.makedirs(args.directory) except OSError as exception: if exception.errno != errno.EEXIST: raise if not hasattr(args, "app_name"): args.app_name = "" if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) args.app_name = self.utils.extract_app_name(args.app_name) hooksObj.statsd_message_list = self.statsd_message_list hookname = "pre_gitpull" hookname_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"{} hook failed.".format(hookname)) # get/update target source(s) repo_name = appObj.getRepoName(repo) path = "{0}/{1}".format(args.directory, repo_name) if os.path.isdir(path): with chdir(path): exit_code = gitObj.gitPull(branch, args.verbose) else: with chdir('{0}'.format(args.directory)): exit_code = gitObj.gitShallowClone(repo, branch, args.verbose) if exit_code != 0: raise ValueError("Gitpull failed.") hooksObj.statsd_message_list = self.statsd_message_list hookname = "post_gitpull" hookname_input_metric = "roger-tools.rogeros_tools_exec_time," + "event=" + hookname + ",app_name=" + str(args.app_name) + ",identifier=" + str(self.identifier) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"{} hook failed.".format(hookname)) except (Exception) as e: printException(e) execution_result = 'FAILURE' raise finally: try: # If the gitpull fails before going through any steps if 'function_execution_start_time' not in globals() and 'function_execution_start_time' not in locals(): function_execution_start_time = datetime.now() if 'execution_result' not in globals() and 'execution_result' not in locals(): execution_result = 'FAILURE' if 'config_name' not in globals() and 'config_name' not in locals(): config_name = "" if 'environment' not in globals() and 'environment' not in locals(): environment = "dev" if not hasattr(args, "app_name"): args.app_name = "" if 'settingObj' not in globals() and 'settingObj' not in locals(): settingObj = Settings() if 'execution_result' is 'FAILURE': self.outcome = 0 sc = self.utils.getStatsClient() if not hasattr(self, "identifier"): self.identifier = self.utils.get_identifier(config_name, settingObj.getUser(), args.app_name) time_take_milliseonds = ((datetime.now() - function_execution_start_time).total_seconds() * 1000) input_metric = "roger-tools.rogeros_tools_exec_time," + "app_name=" + str(args.app_name) + ",event=gitpull" + ",identifier=" + str(self.identifier) + ",outcome=" + str(execution_result) + ",config_name=" + str(config_name) + ",env=" + str(environment) + ",user="******"ERROR - %s" % e, file=sys.stderr) raise print(colored("******Completed the GIT PULL step successfully******", "green"))