ebcli.objects.requests.CreateEnvironmentRequest

Here are the examples of the python api ebcli.objects.requests.CreateEnvironmentRequest taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

58 Examples 7

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_create_environment__app_name_not_passed_in(self):
        with self.assertRaises(TypeError) as context_manager:
            requests.CreateEnvironmentRequest(env_name='my-env')

        self.assertEqual(
            'CreateEnvironmentRequest requires key-word argument app_name',
            str(context_manager.exception)
        )

    def test_create_environment__env_name_not_passed_in(self):

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_create_environment__env_name_not_passed_in(self):
        with self.assertRaises(TypeError) as context_manager:
            requests.CreateEnvironmentRequest(app_name='my-app')

        self.assertEqual(
            'CreateEnvironmentRequest requires key-word argument env_name',
            str(context_manager.exception)
        )

    def test_create_environment__scale_is_not_an_int(self):

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_create_environment__scale_is_not_an_int(self):
        with self.assertRaises(TypeError) as context_manager:
            requests.CreateEnvironmentRequest(app_name='my-app', env_name='my-env', scale='1')

        self.assertEqual(
            'key-word argument scale must be of type int',
            str(context_manager.exception)
        )

    def test_add_option_setting(self):

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_add_option_setting(self):
        request = requests.CreateEnvironmentRequest(app_name='my-app', env_name='my-env')
        request.add_option_setting('MyNameSpace', 'MyOptionName', 'MyValue')

        self.assertEqual(
            [
                {
                    'Namespace': 'MyNameSpace',
                    'OptionName': 'MyOptionName',
                    'Value': 'MyValue'
                }
            ],
            request.option_settings
        )

    def test_add_option_setting__with_resource(self):

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_add_option_setting__with_resource(self):
        request = requests.CreateEnvironmentRequest(app_name='my-app', env_name='my-env')
        request.add_option_setting('MyNameSpace', 'MyOptionName', 'MyValue', resource='MyResource')

        self.assertEqual(
            [
                {
                    'Namespace': 'MyNameSpace',
                    'OptionName': 'MyOptionName',
                    'ResourceName': 'MyResource',
                    'Value': 'MyValue'
                }
            ],
            request.option_settings
        )

    def test_compile_vpc_options__no_vpc_args(self):

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_compile_vpc_options__no_vpc_args(self):
        request = requests.CreateEnvironmentRequest(app_name='my-app', env_name='my-env')
        request_copy = copy.copy(request)

        request_copy.compile_vpc_options()

        self.assertEqual(request, request_copy)

    def test_compile_vpc_options(self):

3 Source : test_request.py
with Apache License 2.0
from aws

    def test_compile_database_options__no_database_args(self):
        request = requests.CreateEnvironmentRequest(app_name='my-app', env_name='my-env')
        request_copy = copy.copy(request)

        request_copy.compile_database_options()

        self.assertEqual(request, request_copy)

    def test_compile_database_options(self):

3 Source : test_environments.py
with Apache License 2.0
from aws

    def test_create_new_environment_envname_taken(self, mock_names):
        mock_names.return_value = ['my-env', 'my-env2']
        self.mock_elasticbeanstalk.create_environment.side_effect = [
            InvalidParameterValueError('Environment env-name already exists.'),
            None,
        ]

        self.mock_input.return_value = 'new-env-name'

        env_request = CreateEnvironmentRequest(
            app_name='app-name',
            env_name='env-name',
        )
        createops.create_env(env_request, interactive=True)
        self.assertEqual(self.mock_elasticbeanstalk.create_environment.call_count, 2)

    def test_create_new_environment_envname_taken_script(self):

3 Source : test_environments.py
with Apache License 2.0
from aws

    def test_create_new_environment_envname_taken_script(self):
        self.mock_elasticbeanstalk.create_environment.side_effect = [
            InvalidParameterValueError('Environment env-name already exists.'),
        ]

        try:
            env_request = CreateEnvironmentRequest(
                app_name='app-name',
                env_name='env-name',
                )
            createops.create_env(env_request, interactive=False)
            self.fail('Should have thrown InvalidParameterValueError')
        except InvalidParameterValueError:
            pass

    def test_create_new_environment_cname_taken(self):

3 Source : test_environments.py
with Apache License 2.0
from aws

    def test_create_new_environment_cname_taken(self):
        self.mock_elasticbeanstalk.create_environment.side_effect = [
            InvalidParameterValueError('DNS name (cname) is not available.'),
            None,
        ]

        self.mock_input.return_value = 'new-cname'

        env_request = CreateEnvironmentRequest(
            app_name='app-name',
            env_name='env-name',
            )
        createops.create_env(env_request, interactive=True)

        self.assertEqual(self.mock_elasticbeanstalk.create_environment.call_count, 2)

    def test_create_new_environment_cname_taken_script(self):

3 Source : test_environments.py
with Apache License 2.0
from aws

    def test_create_new_environment_cname_taken_script(self):
        self.mock_elasticbeanstalk.create_environment.side_effect = [
            InvalidParameterValueError('DNS name (cname) is not available.'),
        ]

        try:
            env_request = CreateEnvironmentRequest(
                app_name='app-name',
                env_name='env-name',
                )
            createops.create_env(env_request, interactive=False)
            self.fail('Should have thrown InvalidParameterValueError')
        except InvalidParameterValueError:
            pass

    def test_create_new_environment_app_notexists(self):

3 Source : test_environments.py
with Apache License 2.0
from aws

    def test_create_new_environment_app_notexists(self):
        self.mock_elasticbeanstalk.create_environment.side_effect = [
            InvalidParameterValueError('Application \'app-name\' already exists.'),
        ]

        try:
            env_request = CreateEnvironmentRequest(
                app_name='app-name',
                env_name='env-name',
                )
            createops.create_env(env_request, interactive=True)
            self.fail('Should have thrown InvalidParameterValueError')
        except InvalidParameterValueError:
            pass

    def test_create_new_environment_app_notexists_script(self):

3 Source : test_environments.py
with Apache License 2.0
from aws

    def test_create_new_environment_app_notexists_script(self):
        self.mock_elasticbeanstalk.create_environment.side_effect = [
            InvalidParameterValueError('Application \'app-name\' already exists.'),
        ]

        try:
            env_request = CreateEnvironmentRequest(
                app_name='app-name',
                env_name='env-name',
                )
            createops.create_env(env_request, interactive=False)
            self.fail('Should have thrown InvalidParameterValueError')
        except InvalidParameterValueError:
            pass

0 Source : create.py
with Apache License 2.0
from aws

    def do_command(self):
        env_name = self.app.pargs.environment_name
        modules = self.app.pargs.modules
        if modules and len(modules) > 0:
            self.compose_multiple_apps()
            return
        group = self.app.pargs.env_group_suffix
        cname = self.app.pargs.cname
        tier = self.app.pargs.tier
        itype = self.app.pargs.instance_type
        platform = self.app.pargs.platform
        single = self.app.pargs.single
        iprofile = self.app.pargs.instance_profile
        service_role = self.app.pargs.service_role
        label = self.app.pargs.version
        branch_default = self.app.pargs.branch_default
        key_name = self.app.pargs.keyname
        sample = self.app.pargs.sample
        nohang = self.app.pargs.nohang
        tags = self.app.pargs.tags
        envvars = self.app.pargs.envvars
        scale = self.app.pargs.scale
        timeout = self.app.pargs.timeout
        cfg = self.app.pargs.cfg
        elb_type = self.app.pargs.elb_type
        shared_lb = self.app.pargs.shared_lb
        shared_lb_port = self.app.pargs.shared_lb_port
        source = self.app.pargs.source
        process = self.app.pargs.process
        enable_spot = self.app.pargs.enable_spot
        spot_max_price = self.app.pargs.spot_max_price
        instance_types = self.app.pargs.instance_types
        on_demand_base_capacity = self.app.pargs.on_demand_base_capacity
        on_demand_above_base_capacity = self.app.pargs.on_demand_above_base_capacity
        max_instances = self.app.pargs.max_instances
        min_instances = self.app.pargs.min_instances

        interactive = False if env_name else True

        provided_env_name = env_name

        if sample and label:
            raise InvalidOptionsError(strings['create.sampleandlabel'])

        if single and scale:
            raise InvalidOptionsError(strings['create.singleandsize'])

        if (max_instances or min_instances) and scale:
            raise InvalidOptionsError(strings['create.scaleandminmax'])

        if (max_instances or min_instances) and single:
            raise InvalidOptionsError(strings['create.singleandminmax'])

        if single and elb_type:
            raise InvalidOptionsError(strings['create.single_and_elb_type'])

        if single and shared_lb:
            raise InvalidOptionsError(alerts['create.can_not_use_options_together'].format("--single", "--shared-lb"))

        if (shared_lb or shared_lb_port) and elb_type != 'application':
            raise InvalidOptionsError(alerts['sharedlb.wrong_elb_type'])

        if shared_lb_port and not shared_lb:
            raise InvalidOptionsError(alerts['sharedlb.missing_shared_lb'])

        if cname and tier and Tier.looks_like_worker_tier(tier):
            raise InvalidOptionsError(strings['worker.cname'])

        if cname and not elasticbeanstalk.is_cname_available(cname):
            raise AlreadyExistsError(
                strings['cname.unavailable'].replace('{cname}', cname)
            )

        if tier and Tier.looks_like_worker_tier(tier):
            if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets or self.app.pargs.vpc_publicip:
                raise InvalidOptionsError(strings['create.worker_and_incompatible_vpc_arguments'])

        if (not tier or Tier.looks_like_webserver_tier(tier)) and single:
            if self.app.pargs.vpc_elbpublic or self.app.pargs.vpc_elbsubnets:
                raise InvalidOptionsError(strings['create.single_and_elbpublic_or_elb_subnet'])

        if (spot_max_price or on_demand_base_capacity or on_demand_above_base_capacity) and not enable_spot:
            raise InvalidOptionsError(strings['create.missing_enable_spot'])

        if instance_types is "":
            raise InvalidOptionsError(strings['spot.instance_types_validation'])

        if itype and instance_types:
            raise InvalidOptionsError(strings['create.itype_and_instances'])

        platform = _determine_platform(platform, iprofile)

        app_name = self.get_app_name()
        tags = tagops.get_and_validate_tags(tags)
        envvars = get_and_validate_envars(envvars)
        process_app_version = fileoperations.env_yaml_exists() or process
        template_name = get_template_name(app_name, cfg)
        tier = get_environment_tier(tier)
        env_name = provided_env_name or get_environment_name(app_name, group)
        cname = cname or get_environment_cname(env_name, provided_env_name, tier)
        key_name = key_name or commonops.get_default_keyname()
        vpc = self.form_vpc_object(tier, single)
        elb_type = elb_type or get_elb_type_from_customer(interactive, single, tier)
        shared_lb = get_shared_load_balancer(interactive, elb_type, platform, shared_lb, vpc)
        shared_lb_port = shared_lb_port or shared_lb_ops.get_shared_lb_port_from_customer(interactive, shared_lb)
        enable_spot = enable_spot or spotops.get_spot_request_from_customer(interactive)
        instance_types = instance_types or spotops.get_spot_instance_types_from_customer(interactive, enable_spot)
        database = self.form_database_object()

        if not timeout and database:
            timeout = 15

        env_request = CreateEnvironmentRequest(
            app_name=app_name,
            env_name=env_name,
            group_name=group,
            cname=cname,
            template_name=template_name,
            platform=platform,
            tier=tier,
            instance_type=itype,
            version_label=label,
            instance_profile=iprofile,
            service_role=service_role,
            single_instance=single,
            key_name=key_name,
            sample_application=sample,
            tags=tags,
            scale=scale,
            database=database,
            vpc=vpc,
            elb_type=elb_type,
            shared_lb = shared_lb,
            shared_lb_port = shared_lb_port,
            enable_spot=enable_spot,
            instance_types=instance_types,
            spot_max_price=spot_max_price,
            on_demand_base_capacity=on_demand_base_capacity,
            on_demand_above_base_capacity=on_demand_above_base_capacity,
            min_instances=min_instances,
            max_instances=max_instances)

        env_request.option_settings += envvars

        createops.make_new_env(env_request,
                               branch_default=branch_default,
                               process_app_version=process_app_version,
                               nohang=nohang,
                               interactive=interactive,
                               timeout=timeout,
                               source=source)

    def form_database_object(self):

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactive_standard(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name
        load_balancer_choice = '1'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            load_balancer_choice,
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            elb_type='classic'
        )

        self.app = EB(argv=['create'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(3, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactive_standard__webserver_single_instance(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name

        get_input_mock.side_effect = [
            env_name,
            cname_prefix
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            single_instance=True
        )

        self.app = EB(argv=['create', '--single'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(2, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactive_standard__worker_tier(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'

        get_input_mock.side_effect = [
            env_name
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            tier=Tier.from_raw_string('worker'),
        )

        self.app = EB(argv=['create', '--tier', 'worker'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(1, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactive_standard__worker_single_instance(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'

        get_input_mock.side_effect = [
            env_name
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            single_instance=True,
            tier=Tier.from_raw_string('worker'),
        )

        self.app = EB(argv=['create', '--single', '--tier', 'worker'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(1, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactive__simulate_hitting_enter_on_all_input_prompts_to_show_defaults_will_be_picked(
            self,
            get_spot_request_from_customer_mock,
            get_unique_cname_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_unique_cname_mock.return_value = self.app_name + '-dev'
        get_input_mock.return_value = None
        get_spot_request_from_customer_mock.return_value = None

        self.app = EB(argv=['create', '--elb-type', 'classic'])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=self.app_name + '-dev',
            cname=self.app_name + '-dev',
            platform=self.solution,
            elb_type='classic'
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(2, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive_mode(
            self,
            get_spot_request_from_customer_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_input_mock
    ):
        """
        Provide env name and tier and elb_type as command line options.
        Command should now no longer be interactive and it should ask no questions.
        """
        env_name = 'my-awesome-env'
        _determine_platform_mock.return_value = self.solution
        get_spot_request_from_customer_mock.return_value = None

        self.app = EB(argv=['create', env_name, '--elb-type', 'classic'])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=None,
            platform=self.solution,
            elb_type='classic'
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(0, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_non_interactive_mode__all_options(
            self,
            get_spot_request_from_customer_mock,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            get_and_validate_tags_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_input_mock
    ):
        env_name = 'my-awesome-env'
        cname_prefix = env_name + '1'
        application_load_balancer_choice = '1'
        profile = 'myprofile'
        tier = 'webserver'
        itype = 'c3.large'
        keyname ='mykey'
        _determine_platform_mock.return_value = self.solution
        get_default_keyname_mock.return_value = True
        is_cname_available_mock.return_value = True
        get_spot_request_from_customer_mock.return_value = None

        get_and_validate_tags_mock.return_value = [
            {'Key': 'a', 'Value': '1'},
            {'Key': 'b', 'Value': '2'}
        ]
        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            application_load_balancer_choice,
        ]
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'

        self.app = EB(
            argv=[
                'create', env_name,
                '-c', cname_prefix,
                '-ip', profile,
                '-r', 'us-east-1',
                '-t', 'webserver',
                '-i', itype,
                '-p', self.solution.name,
                '-k', keyname,
                '--scale', '3',
                '--tags', 'a=1,b=2', '--elb-type', 'classic',
                '--envvars', 'DB_USER="root",DB_PASSWORD="password"',
                '-d',
                '--sample',
            ]
        )
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            instance_profile=profile,
            tier=Tier.from_raw_string(tier),
            sample_application=True,
            instance_type=itype,
            key_name=keyname,
            scale=3,
            tags=[{'Key': 'a', 'Value': '1'}, {'Key': 'b', 'Value': '2'}],
            elb_type='classic'
        )
        expected_environment_request.option_settings = [
            {
             'Namespace': 'aws:elasticbeanstalk:application:environment',
             'OptionName': 'DB_USER',
             'Value': 'root'
            },
            {
             'Namespace': 'aws:elasticbeanstalk:application:environment',
             'OptionName': 'DB_PASSWORD',
             'Value': 'password'
            }
        ]

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(kwargs['branch_default'], True)

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactively__with_process_flag(
            self,
            get_spot_request_from_customer_mock,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_spot_request_from_customer_mock.return_value = None

        self.app = EB(argv=['create', '--process', self.env_name])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=self.env_name,
            platform=self.solution,
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=True,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__min_max_instances__valid(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        min_instances = '5'
        max_instances = '15'

        self.app = EB(argv=['create', env_name, '--min-instances', min_instances, '--max-instances', max_instances])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            max_instances=max_instances,
            min_instances=min_instances
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__min_max_instances_with_spot(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        min_instances = '15'
        max_instances = '5'
        on_demand_base_capacity = '7'

        self.app = EB(argv=[
            'create', env_name,
            '--enable-spot',
            '--min-instances', min_instances,
            '--max-instances', max_instances,
            '--on-demand-base-capacity', on_demand_base_capacity])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            enable_spot=True,
            on_demand_base_capacity=on_demand_base_capacity,
            max_instances=max_instances,
            min_instances=min_instances
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__spot_request(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        instance_types='t2.micro, t3.micro'

        self.app = EB(argv=['create', env_name, '--enable-spot', '--instance-types', instance_types])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            enable_spot=True,
            instance_types=instance_types
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__instance_types_only(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        instance_types="t2.micro, t3.micro"

        self.app = EB(argv=['create', env_name, '--instance-types', instance_types])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            enable_spot=None,
            instance_types=instance_types
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__all_spot_options__shorthand(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        instance_types="t2.micro, t3.micro"
        spot_max_price = ".05"
        spot_on_demand_base = "2"
        spot_on_demand_above_base = "50"

        self.app = EB(argv=[
            'create', env_name,
            '-es',
            '-it', instance_types,
            '-sm', spot_max_price,
            '-sb', spot_on_demand_base,
            '-sp', spot_on_demand_above_base])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            enable_spot=True,
            instance_types=instance_types,
            spot_max_price=spot_max_price,
            on_demand_base_capacity=spot_on_demand_base,
            on_demand_above_base_capacity=spot_on_demand_above_base
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__all_shared_lb_options(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        shared_lb = 'arn:aws:elasticloadbalancing:us-east-1:881508045124:loadbalancer/app/alb-1/72074d479748b405'
        shared_lb_port = '80'
        load_balancer_type = 'application'

        self.app = EB(argv=[
            'create', env_name,
            '--elb-type', load_balancer_type,
            '--shared-lb', shared_lb,
            '--shared-lb-port', shared_lb_port])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            elb_type=load_balancer_type,
            env_name=env_name,
            platform=self.solution,
            shared_lb=shared_lb,
            shared_lb_port=shared_lb_port
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactive__shared_lb_only_request(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        env_name = 'my-awesome-env'
        shared_lb = 'arn:aws:elasticloadbalancing:us-east-1:881508045124:loadbalancer/app/alb-1/72074d479748b405'
        load_balancer_type = 'application'

        self.app = EB(argv=[
            'create', env_name,
            '--elb-type', load_balancer_type,
            '--shared-lb', shared_lb])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            elb_type=load_balancer_type,
            platform=self.solution,
            shared_lb=shared_lb,
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source=None
        )

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create__env_yaml_present__environment_name_present_in_yaml_file__group_name_is_passed(
            self,
            get_spot_request_from_customer_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_input_mock
    ):
        with open('env.yaml', 'w') as env_yaml:
            env_yaml.write("""AWSConfigurationTemplateVersion: 1.1.0.0
SolutionStack: 64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)
CName: front-A08G28LG+
EnvironmentName: front+""")

        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_spot_request_from_customer_mock.return_value = None

        self.app = EB(argv=['create', '--elb-type', 'network', '--cname', 'available-cname', '--env-group-suffix', 'dev'])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name='front-dev',
            cname='available-cname',
            platform=self.solution,
            elb_type='network',
            group_name='dev',
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(0, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create__env_yaml_present__environment_name_present_in_yaml_file__group_name_is_passed__worker_tier(
            self,
            get_spot_request_from_customer_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_input_mock
    ):
        with open('env.yaml', 'w') as env_yaml:
            env_yaml.write("""AWSConfigurationTemplateVersion: 1.1.0.0
SolutionStack: 64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)
CName: front-A08G28LG+
EnvironmentName: front+""")

        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_spot_request_from_customer_mock.return_value = None

        self.app = EB(argv=['create', '--tier', 'worker', '--env-group-suffix', 'dev'])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name='front-dev',
            platform=self.solution,
            group_name='dev',
            tier=Tier.from_raw_string('worker'),
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(0, get_input_mock.call_count)

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create__env_yaml_present__environment_name_absent_in_yaml_file__customer_is_prompted_for_input__group_suffix_discarded(
            self,
            get_spot_request_from_customer_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_input_mock
    ):
        with open('env.yaml', 'w') as env_yaml:
            env_yaml.write("""AWSConfigurationTemplateVersion: 1.1.0.0
SolutionStack: 64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)
CName: front-A08G28LG+""")

        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None

        get_input_mock.side_effect = [
            'my-environment-name'
        ]
        self.app = EB(argv=['create', '--elb-type', 'network', '--cname', 'available-cname', '--env-group-suffix', 'dev'])
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name='my-environment-name',
            cname='available-cname',
            platform=self.solution,
            elb_type='network',
            group_name='dev',
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(1, get_input_mock.call_count)

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactively__with_forward_slash_in_branch(
            self,
            is_cname_available_mock,
            get_default_keyname_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None

        self.app = EB(
            argv=[
                'create',
                self.env_name,
                '--source', 'codecommit/my-repository/my-branch/feature'
            ]
        )
        self.app.setup()
        self.app.run()

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=self.env_name,
            platform=self.solution,
        )
        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]
        self.assertEqual(actual_environment_request, expected_environment_request)
        make_new_env_mock.assert_called_with(
            expected_environment_request,
            branch_default=False,
            process_app_version=False,
            nohang=False,
            interactive=False,
            timeout=None,
            source='codecommit/my-repository/my-branch/feature'
        )


class TestCreateWithDatabaseAndVPCE2E(TestCreateBase):

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_database__db_argument_triggers_interactive_database_options(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_pass_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name
        load_balancer_choice = '1'
        database_user_name = 'root'
        database_password = 'password'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            load_balancer_choice,
            database_user_name
        ]
        get_pass_mock.side_effect = [
            database_password
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            elb_type='classic',
            database={
                'username': 'root',
                'password': 'password',
                'engine': None,
                'size': None,
                'instance': None,
                'version': None
            },
        )

        self.app = EB(argv=['create', '-db'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(4, get_input_mock.call_count)
        self.assertEqual(1, get_pass_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_database__db_username_passed_in_password_requested(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_pass_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name
        load_balancer_choice = '1'
        database_password = 'password'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            load_balancer_choice
        ]
        get_pass_mock.side_effect = [
            database_password
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            elb_type='classic',
            database={
                'username': 'root',
                'password': 'password',
                'engine': None,
                'size': None,
                'instance': None,
                'version': None
            },
        )

        self.app = EB(argv=['create', '-db.user', 'root'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(3, get_input_mock.call_count)
        self.assertEqual(1, get_pass_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_database__db_username_password_and_other_arguments_passed(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name
        load_balancer_choice = '1'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            load_balancer_choice
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            elb_type='classic',
            database={
                'username': 'root',
                'password': 'password',
                'engine': 'mysql',
                'size': None,
                'instance': None,
                'version': '5.6.35'
            },
        )

        self.app = EB(argv=['create', '-db.user', 'root', '-db.pass', 'password', '-db.engine', 'mysql', '-db.version', '5.6.35'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(3, get_input_mock.call_count)

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactively_with_database__db_username_password_and_other_arguments_passed(
            self,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None

        env_name = 'my-awesome-env'

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            elb_type='application',
            database={
                'username': 'root',
                'password': 'password',
                'engine': 'mysql',
                'size': '10',
                'instance': 'db.t2.micro',
                'version': '5.6.35'
            },
        )

        self.app = EB(
            argv=[
                'create', env_name,
                '--elb-type', 'application',
                '-db.user', 'root',
                '-db.pass', 'password',
                '-db.engine', 'mysql',
                '-db.version', '5.6.35',
                '-db.size', '10',
                '-db.i', 'db.t2.micro',
            ]
        )
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_custom_vpc__vpc_argument_triggers_interactive_vpc_options(
            self,
            get_shared_lb_from_customer_mock,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_boolean_response_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_spot_request_from_customer_mock.return_value = None
        get_shared_lb_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name
        vpc_id = 'my-vpc-id'
        ec2subnets = 'subnet-1,subnet-2,subnet-3'
        is_publicip = 'y'
        elbsubnets = 'subnet-1,subnet-2,subnet-3'
        securitygroups = 'security-group-1,security-group-2'
        is_elbpublic = 'n'
        load_balancer_choice = '1'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            vpc_id,
            ec2subnets,
            elbsubnets,
            securitygroups,
            load_balancer_choice
        ]
        get_boolean_response_mock.side_effect = [
            is_publicip,
            is_elbpublic
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': 'subnet-1,subnet-2,subnet-3',
                'elbscheme': 'public',
                'publicip': 'true',
                'securitygroups': 'security-group-1,security-group-2',
                'dbsubnets': None
            },
            elb_type='classic'
        )

        self.app = EB(argv=['create', '--vpc'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(7, get_input_mock.call_count)
        self.assertEqual(2, get_boolean_response_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_custom_vpc__vpc_argument_triggers_interactive_vpc_options__tier_type_worker(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        vpc_id = 'my-vpc-id'
        ec2subnets = 'subnet-1,subnet-2,subnet-3'
        securitygroups = 'security-group-1,security-group-2'

        get_input_mock.side_effect = [
            env_name,
            vpc_id,
            ec2subnets,
            securitygroups
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            tier=Tier.from_raw_string('worker'),
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': None,
                'elbscheme': None,
                'publicip': None,
                'securitygroups': 'security-group-1,security-group-2',
                'dbsubnets': None
            }
        )

        self.app = EB(argv=['create', '--vpc', '--tier', 'worker'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(4, get_input_mock.call_count)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_custom_vpc__vpc_argument_triggers_interactive_vpc_options__single_instance_webserver(
            self,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_boolean_response_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_input_mock
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_unique_cname_mock.return_value = 'my-awesome-env'
        get_spot_request_from_customer_mock.return_value = None

        env_name = 'my-awesome-env'
        cname_prefix = env_name
        load_balancer_choice = '1'
        vpc_id = 'my-vpc-id'
        ec2subnets = 'subnet-1,subnet-2,subnet-3'
        is_publicip = 'y'
        securitygroups = 'security-group-1,security-group-2'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            vpc_id,
            ec2subnets,
            securitygroups
        ]
        get_boolean_response_mock.side_effect = [
            is_publicip,
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=cname_prefix,
            platform=self.solution,
            single_instance=True,
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': None,
                'elbscheme': None,
                'publicip': 'true',
                'securitygroups': 'security-group-1,security-group-2',
                'dbsubnets': None
            }
        )

        self.app = EB(argv=['create', '--vpc', '--single'])
        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)
        self.assertEqual(5, get_input_mock.call_count)
        self.assertEqual(1, get_boolean_response_mock.call_count)

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_custom_vpc__vpc_argument_triggers_interactive_vpc_prompts__some_vpc_arguments_already_passed_in(
            self,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None

        env_name = 'my-awesome-env'

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': 'subnet-1,subnet-2,subnet-3',
                'elbscheme': 'public',
                'publicip': 'true',
                'securitygroups': None,
                'dbsubnets': None
            }
        )

        self.app = EB(
            argv=[
                'create', env_name,
                '--vpc.id', 'my-vpc-id',
                '--vpc.ec2subnets', 'subnet-1,subnet-2,subnet-3',
                '--vpc.publicip',
                '--vpc.elbsubnets', 'subnet-1,subnet-2,subnet-3',
                '--vpc.elbpublic'
            ]
        )

        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)

    @mock.patch('ebcli.core.io.get_input')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_interactively_with_database_and_vpc_arguments(
            self,
            get_shared_lb_from_customer_mock,
            get_spot_request_from_customer_mock,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
            get_unique_environment_name_mock,
            get_unique_cname_mock,
            get_pass_mock,
            get_boolean_response_mock,
            get_input_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None
        get_unique_environment_name_mock.return_value = self.app_name + '-dev'
        get_spot_request_from_customer_mock.return_value = None
        get_shared_lb_from_customer_mock.return_value = None


        env_name = 'my-awesome-env'
        cname_prefix = env_name
        get_unique_cname_mock.return_value = cname_prefix

        vpc_id = 'my-vpc-id'
        ec2subnets = 'subnet-1,subnet-2,subnet-3'
        is_ec2_public = 'y'
        elbsubnets = 'subnet-1,subnet-2,subnet-3'
        securitygroups = 'security-group-1,security-group-2'
        is_elb_public = 'y'
        rdssubnets = 'subnet-1,subnet-2,subnet-3'

        load_balancer_choice = '1'
        database_user_name = 'root'
        database_password = 'password'

        get_input_mock.side_effect = [
            env_name,
            cname_prefix,
            vpc_id,
            ec2subnets,
            elbsubnets,
            securitygroups,
            rdssubnets,
            load_balancer_choice,
            database_user_name,
        ]
        get_boolean_response_mock.side_effect = [
            is_ec2_public,
            is_elb_public
        ]
        get_pass_mock.side_effect = [
            database_password
        ]

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            cname=env_name,
            platform=self.solution,
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': 'subnet-1,subnet-2,subnet-3',
                'elbscheme': 'public',
                'publicip': 'true',
                'securitygroups': 'security-group-1,security-group-2',
                'dbsubnets': 'subnet-1,subnet-2,subnet-3',
            },
            elb_type='classic',
            database={
                'username': 'root',
                'password': 'password',
                'engine': None,
                'size': None,
                'instance': None,
                'version': None
            }
        )

        self.app = EB(
            argv=[
                'create', '-db', '--vpc',
            ]
        )

        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)

    @mock.patch('ebcli.operations.createops.make_new_env')

0 Source : test_create.py
with Apache License 2.0
from aws

    def test_create_non_interactively_with_database_and_vpc_arguments(
            self,
            get_default_keyname_mock,
            is_cname_available_mock,
            _determine_platform_mock,
            make_new_env_mock,
    ):
        _determine_platform_mock.return_value = self.solution
        is_cname_available_mock.return_value = True
        get_default_keyname_mock.return_value = None

        env_name = 'my-awesome-env'

        self.app = EB(
            argv=[
                'create', env_name,

                '-db',
                '-db.user', 'root',
                '-db.pass', 'password',
                '-db.i', 'db.t2.micro',
                '-db.version', '5.6.35',
                '-db.size', '10',
                '-db.engine', 'mysql',

                '--vpc',
                '--vpc.id', 'my-vpc-id',
                '--vpc.ec2subnets', 'subnet-1,subnet-2,subnet-3',
                '--vpc.publicip',
                '--vpc.elbsubnets', 'subnet-1,subnet-2,subnet-3',
                '--vpc.securitygroups', 'security-group-1,security-group-2',
                '--vpc.elbpublic',
                '--vpc.dbsubnets', 'subnet-1,subnet-2,subnet-3',
            ]
        )

        expected_environment_request = CreateEnvironmentRequest(
            app_name=self.app_name,
            env_name=env_name,
            platform=self.solution,
            database={
                'username': 'root',
                'password': 'password',
                'engine': 'mysql',
                'size': '10',
                'instance': 'db.t2.micro',
                'version': '5.6.35'
            },
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': 'subnet-1,subnet-2,subnet-3',
                'elbscheme': 'public',
                'publicip': 'true',
                'securitygroups': 'security-group-1,security-group-2',
                'dbsubnets': 'subnet-1,subnet-2,subnet-3',
            }
        )

        self.app.setup()
        self.app.run()

        call_args, kwargs = make_new_env_mock.call_args
        actual_environment_request = call_args[0]

        self.assertEnvironmentRequestsEqual(expected_environment_request, actual_environment_request)


class TestCreateModuleE2E(unittest.TestCase):

0 Source : test_elasticbeanstalk.py
with Apache License 2.0
from aws

    def test_create_environment(
            self,
            has_default_vpc_mock,
            get_region_name_mock,
            make_api_call_mock
    ):
        self.maxDiff = None
        has_default_vpc_mock.return_value = True
        get_region_name_mock.return_value = 'us-east-1'
        make_api_call_mock.return_value = mock_responses.CREATE_ENVIRONMENT_RESPONSE
        environment_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            platform=PlatformVersion("arn:aws:elasticbeanstalk:us-west-2::platform/Docker running on 64bit Amazon Linux/2.1.0"),
            database={
                'username': 'root',
                'password': 'password',
                'engine': 'mysql',
                'size': '10',
                'instance': 'db.t2.micro',
                'version': '5.6.35'
            },
            vpc={
                'id': 'my-vpc-id',
                'ec2subnets': 'subnet-1,subnet-2,subnet-3',
                'elbsubnets': 'subnet-1,subnet-2,subnet-3',
                'elbscheme': 'public',
                'publicip': 'true',
                'securitygroups': 'security-group-1,security-group-2',
                'dbsubnets': 'subnet-1,subnet-2,subnet-3',
            }
        )

        elasticbeanstalk.create_environment(environment_request)

        make_api_call_mock.assert_called_once_with(
            'elasticbeanstalk',
            'create_environment',
            ApplicationName='my-application',
            Description='Environment created from the EB CLI using "eb create"',
            EnvironmentName='environment-1',
            OptionSettings=[
                {
                    'Namespace': 'aws:elasticbeanstalk:healthreporting:system',
                    'OptionName': 'SystemType',
                    'Value': 'enhanced'
                },
                {
                    'Namespace': 'aws:elasticbeanstalk:command',
                    'OptionName': 'BatchSize',
                    'Value': '30'
                },
                {
                    'Namespace': 'aws:elasticbeanstalk:command',
                    'OptionName': 'BatchSizeType',
                    'Value': 'Percentage'
                },
                {
                    'Namespace': 'aws:elb:policies',
                    'OptionName': 'ConnectionDrainingEnabled',
                    'Value': 'true'
                },
                {
                    'Namespace': 'aws:elb:loadbalancer',
                    'OptionName': 'CrossZone',
                    'Value': 'true'
                },
                {
                    'Namespace': 'aws:autoscaling:updatepolicy:rollingupdate',
                    'OptionName': 'RollingUpdateEnabled',
                    'Value': 'true'
                },
                {
                    'Namespace': 'aws:autoscaling:updatepolicy:rollingupdate',
                    'OptionName': 'RollingUpdateType',
                    'Value': 'Health'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBPassword',
                    'Value': 'password'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBUser',
                    'Value': 'root'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBInstanceClass',
                    'Value': 'db.t2.micro'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBAllocatedStorage',
                    'Value': '10'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBEngine',
                    'Value': 'mysql'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBEngineVersion',
                    'Value': '5.6.35'
                },
                {
                    'Namespace': 'aws:rds:dbinstance',
                    'OptionName': 'DBDeletionPolicy',
                    'Value': 'Snapshot'
                },
                {
                    'Namespace': 'aws:ec2:vpc',
                    'OptionName': 'VPCId',
                    'Value': 'my-vpc-id'
                },
                {
                    'Namespace': 'aws:ec2:vpc',
                    'OptionName': 'AssociatePublicIpAddress',
                    'Value': 'true'
                },
                {
                    'Namespace': 'aws:ec2:vpc',
                    'OptionName': 'ELBScheme',
                    'Value': 'public'
                },
                {
                    'Namespace': 'aws:ec2:vpc',
                    'OptionName': 'ELBSubnets',
                    'Value': 'subnet-1,subnet-2,subnet-3'
                },
                {
                    'Namespace': 'aws:ec2:vpc',
                    'OptionName': 'Subnets',
                    'Value': 'subnet-1,subnet-2,subnet-3'
                },
                {
                    'Namespace': 'aws:autoscaling:launchconfiguration',
                    'OptionName': 'SecurityGroups',
                    'Value': 'security-group-1,security-group-2'
                },
                {
                    'Namespace': 'aws:ec2:vpc',
                    'OptionName': 'DBSubnets',
                    'Value': 'subnet-1,subnet-2,subnet-3'
                }
            ],
            PlatformArn='arn:aws:elasticbeanstalk:us-west-2::platform/Docker running on 64bit Amazon Linux/2.1.0',
            TemplateSpecification={
                'TemplateSnippets': [
                    {
                        'SnippetName': 'RdsExtensionEB',
                        'Order': 10000,
                        'SourceUrl': 'https://s3.amazonaws.com/elasticbeanstalk-env-resources-us-east-1/eb_snippets/rds/rds.json'
                    }
                ]
            }
        )

    @mock.patch('ebcli.lib.elasticbeanstalk.aws.make_api_call')

0 Source : test_createops.py
with Apache License 2.0
from aws

    def test_resolve_roles__non_interactive_mode__request_does_not_contain_profile__existing_role_retrieved_from_service(
            self,
            get_service_role_mock,
            create_default_instance_profile_mock
    ):
        create_default_instance_profile_mock.return_value = 'default-profile'
        get_service_role_mock.return_value = 'service-role'
        env_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            cname='cname-1',
            platform=SolutionStack('64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)'),
            elb_type='network',
            group_name='dev',
        )

        createops.resolve_roles(env_request, False)
        create_default_instance_profile_mock.assert_called_once_with()
        self.assertEqual(
            'service-role',
            env_request.service_role
        )

    @mock.patch('ebcli.operations.createops.commonops.create_default_instance_profile')

0 Source : test_createops.py
with Apache License 2.0
from aws

    def test_resolve_roles__non_interactive_mode__profile_passed_is_default_role_name__existing_role_retrieved_from_service(
            self,
            get_service_role_mock,
            create_default_instance_profile_mock
    ):
        create_default_instance_profile_mock.return_value = 'default-profile'
        get_service_role_mock.return_value = 'service-role'
        env_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            cname='cname-1',
            platform=SolutionStack('64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)'),
            elb_type='network',
            group_name='dev',
            instance_profile='aws-elasticbeanstalk-ec2-role'
        )

        createops.resolve_roles(env_request, False)
        create_default_instance_profile_mock.assert_called_once_with()

    @mock.patch('ebcli.operations.createops.commonops.create_default_instance_profile')

0 Source : test_createops.py
with Apache License 2.0
from aws

    def test_resolve_roles__non_interactive_mode__profile_passed_is_other_role_name_other_than_service_role__existing_role_retrieved_from_service(
            self,
            get_service_role_mock,
            create_default_instance_profile_mock
    ):
        get_service_role_mock.return_value = 'service-role'
        env_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            cname='cname-1',
            platform=SolutionStack('64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)'),
            elb_type='network',
            group_name='dev',
            instance_profile='developer'
        )

        createops.resolve_roles(env_request, False)

        create_default_instance_profile_mock.assert_not_called()

    @mock.patch('ebcli.operations.createops.commonops.create_default_instance_profile')

0 Source : test_createops.py
with Apache License 2.0
from aws

    def test_resolve_roles__non_interactive_mode__no_healthd_support_for_platform__service_role_cannot_determined(
            self,
            get_service_role_mock,
            create_default_instance_profile_mock
    ):
        env_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            cname='cname-1',
            platform=SolutionStack('64bit Windows Server Core 2016 v1.2.0 running IIS 10.0'),
            elb_type='network',
            group_name='dev',
            instance_profile='developer'
        )

        createops.resolve_roles(env_request, False)

        get_service_role_mock.assert_not_called()
        create_default_instance_profile_mock.assert_not_called()
        self.assertIsNone(env_request.service_role)

    @mock.patch('ebcli.operations.createops.commonops.create_default_instance_profile')

0 Source : test_createops.py
with Apache License 2.0
from aws

    def test_resolve_roles__non_interactive_mode__no_healthd_support_for_platform__service_role_already_assigned_to_create_environment_request(
            self,
            get_service_role_mock,
            create_default_instance_profile_mock
    ):
        env_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            cname='cname-1',
            platform=SolutionStack('64bit Windows Server Core 2016 v1.2.0 running IIS 10.0'),
            elb_type='network',
            group_name='dev',
            instance_profile='developer',
            service_role='aws-elasticbeanstalk-service-role'
        )

        createops.resolve_roles(env_request, False)

        get_service_role_mock.assert_not_called()
        create_default_instance_profile_mock.assert_not_called()
        self.assertEqual(
            'aws-elasticbeanstalk-service-role',
            env_request.service_role
        )

    @mock.patch('ebcli.operations.createops.commonops.create_default_instance_profile')

0 Source : test_createops.py
with Apache License 2.0
from aws

    def test_resolve_roles__interactive_mode__service_role_could_not_be_found__simulate_customer_viewing_policies(
            self,
            get_managed_policy_document_mock,
            get_input_mock,
            create_default_service_role_mock,
            get_service_role_mock,
            create_default_instance_profile_mock
    ):
        get_managed_policy_document_mock.side_effect = [
            {
                "PolicyVersion": {
                    "Document": {}
                }
            },
            {
                "PolicyVersion": {
                    "Document": {}
                }
            },
        ]
        get_input_mock.side_effect = [
            'view',
            '\n'
        ]
        create_default_instance_profile_mock.return_value = 'default-profile'
        get_service_role_mock.return_value = None
        create_default_service_role_mock.return_value = 'aws-elasticbeanstalk-service-role'
        env_request = CreateEnvironmentRequest(
            app_name='my-application',
            env_name='environment-1',
            cname='cname-1',
            platform=SolutionStack('64bit Amazon Linux 2015.09 v2.0.6 running Multi-container Docker 1.7.1 (Generic)'),
            elb_type='network',
            group_name='dev',
        )

        createops.resolve_roles(env_request, True)
        self.assertEqual(
            'aws-elasticbeanstalk-service-role',
            env_request.service_role
        )

    @mock.patch('ebcli.operations.createops.commonops.create_default_instance_profile')

See More Examples