Example #1
0
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
Example #2
0
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
Example #4
0
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
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
Example #7
0
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 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
Example #9
0
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
Example #10
0
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
Example #11
0
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
Example #12
0
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
Example #13
0
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
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
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
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
Example #17
0
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
Example #18
0
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