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
3
Source : test_request.py
with Apache License 2.0
from aws
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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