def test_validation_file_exists(self): """ Tests that an error is raised if you don't use external, but the key does exist locally. """ ctx = self.mock_ctx('test_validation_file_exists') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair( 'test_validation_file_exists') ctx.node.properties['use_external_resource'] = False ctx.node.properties['resource_id'] = kp.name kp = ec2_client.delete_key_pair( 'test_validation_file_exists') key_path = \ self.create_dummy_key_path(ctx=ctx) self.addCleanup(os.remove, key_path) with open(key_path, 'w') as dummy_key: dummy_key.write('test') ex = self.assertRaises( NonRecoverableError, keypair.creation_validation, ctx=ctx) self.assertIn( 'but the key file exists locally', ex.message)
def test_create_group_rules_both_src_group_id_cidr(self): """ This tests that either src_group_id or cidr_ip is error is raised when neither is given. """ ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group( 'test_create_group_rules_both_src_group_id_or_cidr', 'this is test') test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_create_group_rules_both_src_group_id_or_cidr', test_properties) current_ctx.set(ctx=ctx) test_securitygroup = self.create_sg_for_checking() group_object = ec2_client.create_security_group( 'dummy', 'this is test') ctx.node.properties['rules'][0]['src_group_id'] = group_object ex = self.assertRaises( NonRecoverableError, test_securitygroup._create_group_rules, group) self.assertIn( 'You need to pass either src_group_id OR cidr_ip.', ex.message)
def test_validation_use_external_not_in_account(self): """ Tests that an error is raised if you use external, but the key pair doesn't exist in your account. """ ctx = self.mock_ctx('test_validation_use_external_not_in_account') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair( 'test_validation_use_external_not_in_account') ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = kp.name kp = ec2_client.delete_key_pair( 'test_validation_use_external_not_in_account') key_path = \ self.create_dummy_key_path(ctx=ctx) self.addCleanup(os.remove, key_path) with open(key_path, 'w') as dummy_key: dummy_key.write('test') ex = self.assertRaises(NonRecoverableError, keypair.creation_validation, ctx=ctx) self.assertIn('the key pair does not exist in the account', ex.message) self.assertIn('InvalidKeyPair.NotFound', ex.message)
def test_update_rules(self): """This tests that create creates the runtime_properties""" test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_create_duplicate', test_properties) current_ctx.set(ctx=ctx) name = ctx.node.properties.get('resource_id') description = ctx.node.properties.get('description') ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group(name, description) ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = group.id with mock.patch( 'cloudify_aws.ec2.securitygroup.' 'SecurityGroup.get_resource_state') as securitygroup_state: securitygroup_state.return_value = 'available' securitygroup.create(ctx=ctx) rules = [{ 'ip_protocol': 'udp', 'from_port': '33333', 'to_port': '33333', 'cidr_ip': '192.168.122.40' }] securitygroup.update_rules(rules=rules, ctx=ctx) group_id = \ ctx.instance.runtime_properties[constants.EXTERNAL_RESOURCE_ID] group_list = ec2_client.get_all_security_groups(group_ids=group_id) group = group_list[0] all_rules = rules + ctx.node.properties['rules'] self.assertEqual(len(all_rules), len(group.rules))
def test_create_group_rules_both_src_group_id_cidr(self): """ This tests that either src_group_id or cidr_ip is error is raised when neither is given. """ test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_create_group_rules_both_src_group_id_or_cidr', test_properties) current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group( 'test_create_group_rules_both_src_group_id_or_cidr', 'this is test') test_securitygroup = self.create_sg_for_checking() group_object = ec2_client.create_security_group( 'dummy', 'this is test') # setattr(group_object, 'vpc_id', 'vpc-abcd1234') ctx.node.properties['rules'][0]['src_group_id'] = group_object.id with mock.patch('cloudify_aws.ec2.securitygroup.' 'SecurityGroup.get_resource') as gr: gr.return_value = group ex = self.assertRaises(NonRecoverableError, test_securitygroup._create_group_rules, group) self.assertIn('You cannot pass both cidr_ip and src_group_id', ex.message)
def test_create_group_rules_src_group(self): """ This tests that _create_group_rules creates the rules and that they match on the way out to what when in. """ ec2_client = connection.EC2ConnectionClient().client() test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_create_group_rules_src_group', test_properties) group_object = ec2_client.create_security_group( 'dummy', 'this is test') ctx.node.properties['rules'][0]['src_group_id'] = group_object.id del ctx.node.properties['rules'][0]['cidr_ip'] current_ctx.set(ctx=ctx) with mock.patch( 'cloudify_aws.ec2.securitygroup.' 'SecurityGroup.get_resource_state') as securitygroup_state: securitygroup_state.return_value = 'available' securitygroup.create(ctx=ctx) group = ec2_client.get_all_security_groups( group_ids=ctx.instance.runtime_properties[ constants.EXTERNAL_RESOURCE_ID]) self.assertIn('test_security_group-111122223333', str(group[0].rules[0].grants[0]))
def test_validation_use_external(self): ctx = self.mock_ctx('test_validation_use_external') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair('test_validation_use_external') ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = kp.name ex = self.assertRaises(NonRecoverableError, keypair.creation_validation, ctx=ctx) self.assertIn('but the key file does not exist locally.', ex.message)
def test_delete(self): """This tests that delete removes the runtime_properties""" test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_delete', test_properties) current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group('test', 'this is test') ctx.instance.runtime_properties['aws_resource_id'] = group.id securitygroup.SecurityGroup().deleted() self.assertNotIn('aws_resource_id', ctx.instance.runtime_properties)
def test_execute(self): """ Tests that execute runs and returns the expected return value. """ ctx = self.get_mock_ctx('test_execute') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() resource = AwsBase(client=ec2_client) output = resource.execute(resource.client.run_instances, dict(image_id='ami-e214778a', instance_type='t1.micro')) reservation = resource.client.get_all_reservations() self.assertEqual(output.id, reservation[0].id)
def test_delete(self): """ this tests that keypair delete removes the keypair from the account """ ctx = self.mock_ctx('test_delete') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair('test_delete') ctx.instance.runtime_properties['aws_resource_id'] = kp.name ctx.instance.runtime_properties['key_path'] = \ self.create_dummy_key_path(ctx=ctx) keypair.delete(ctx=ctx) self.assertEquals(None, ec2_client.get_key_pair(kp.name))
def test_create_retry(self): """This tests that create retry works""" test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_create_retry', test_properties, retry_number=1) current_ctx.set(ctx=ctx) name = ctx.node.properties.get('resource_id') description = ctx.node.properties.get('description') ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group(name, description) ctx.instance.runtime_properties[constants.EXTERNAL_RESOURCE_ID] = \ group.id securitygroup.create(ctx=ctx)
def test_create_use_external(self): """ This tests that the create keypair function adds the key_pair_name to runtime properties. """ ctx = self.mock_ctx('test_create_use_external') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair('test_create_use_external') ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = kp.name ex = self.assertRaises(NonRecoverableError, keypair.create, ctx=ctx) self.assertIn('External resource, but the key file does not exist', ex.message)
def test_start(self): """This tests that start adds tags""" ctx = self.mock_ctx('test_start') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() volume = ec2_client.create_volume(TEST_SIZE, TEST_ZONE) volume_id = volume.id ctx.instance.runtime_properties['aws_resource_id'] = volume_id ebs.start(ctx=ctx) volume_list = ec2_client.get_all_volumes(volume_ids=volume_id) volume_object = volume_list[0] self.assertEquals(volume_object.tags.get('resource_id'), ctx.instance.id)
def test_save_key_pair_missing_property(self): """ This tests that _save_key_pair raises an error when private_key_path is not set. """ ctx = self.mock_ctx('test_save_key_pair_missing_property') current_ctx.set(ctx=ctx) test_keypair = self.create_kp_for_checking() ec2_client = connection.EC2ConnectionClient().client() del (ctx.node.properties['private_key_path']) kp = ec2_client.create_key_pair('test_create_use_external') ex = self.assertRaises(NonRecoverableError, test_keypair._save_key_pair, kp) self.assertIn('Unable to get key file path, private_key_path not set', ex.message)
def test_run_instances_external_resource(self): """ this tests that the instance create function adds the runtime_properties """ ctx = self.mock_ctx('test_run_instances_external_resource') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() reservation = ec2_client.run_instances( TEST_AMI_IMAGE_ID, instance_type=TEST_INSTANCE_TYPE) instance_id = reservation.instances[0].id ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = instance_id instance.Instance().create(ctx=ctx) self.assertIn('aws_resource_id', ctx.instance.runtime_properties.keys())
def test_delete(self): """This tests that delete removes the runtime_properties""" test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_delete', test_properties, operation_name='delete') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group('test', 'this is test') ctx.instance.runtime_properties['aws_resource_id'] = group.id with mock.patch('cloudify_aws.base.AwsBaseNode.get_resource', return_value=[]): securitygroup.SecurityGroup().delete_helper() self.assertNotIn('aws_resource_id', ctx.instance.runtime_properties)
def test_create_duplicate(self): """This tests that when you give a name of an existing resource, a NonRecoverableError is raised. """ test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_create_duplicate', test_properties) current_ctx.set(ctx=ctx) name = ctx.node.properties.get('resource_id') description = ctx.node.properties.get('description') ec2_client = connection.EC2ConnectionClient().client() ec2_client.create_security_group(name, description) ex = self.assertRaises( NonRecoverableError, securitygroup.create, ctx=ctx) self.assertIn('InvalidGroup.Duplicate', ex.message)
def test_validation_in_account(self): """ Tests that an error is raised if you don't use external, but the key does exist in your account. """ ctx = self.mock_ctx('test_validation_in_account') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair('test_validation_in_account') ctx.node.properties['use_external_resource'] = False ctx.node.properties['resource_id'] = kp.name ex = self.assertRaises(NonRecoverableError, keypair.creation_validation, ctx=ctx) self.assertIn('but the key pair exists in the account.', ex.message)
def test_create_use_external(self): """ This tests that the create keypair function adds the key_pair_name to runtime properties. """ ctx = self.mock_ctx('test_create_use_external') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() kp = ec2_client.create_key_pair('test_create_use_external') with open(ctx.node.properties['private_key_path'], 'wb') as fp: fp.write(kp.material) fp.close() ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = kp.name keypair.create() self.assertIn('aws_resource_id', ctx.instance.runtime_properties.keys())
def test_get_and_filter_resources_by_matcher(self): """ Tests that get_and_filter_resources_by_matcher returns the right targets_and_types. """ ctx = self.get_mock_ctx('test_get_and_filter_resources_by_matcher') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() resource = AwsBase(client=ec2_client) reservation = ec2_client.run_instances( 'ami-e214778a', instance_type='t1.micro') instance_id = reservation.instances[0].id list_of_ids = [instance_id] filter_function = resource.client.get_all_reservations filters = {'instance_ids': list_of_ids} self.assertEqual(reservation.id, resource.get_and_filter_resources_by_matcher( filter_function, filters)[0].id)
def test_get_all_matching(self): """ Tests that get_all_matching returns the right matched resources. """ ctx = self.get_mock_ctx('test_get_all_matching') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() resource = AwsBaseNode('root', [], ec2_client, resource_states=[]) reservation = ec2_client.run_instances( 'ami-e214778a', instance_type='t1.micro') instance_id = reservation.instances[0].id list_of_ids = [instance_id] resource.get_all_handler['function'] = \ resource.client.get_all_reservations resource.get_all_handler['argument'] = 'instance_ids' self.assertEqual(reservation.id, resource.get_all_matching(list_of_ids)[0].id)
def test_get_private_dns_name(self): """ This checks that _get_instance_attribute sets the correct runtime property and it is an FQDN """ ctx = self.mock_ctx('test_get_private_dns_name') current_ctx.set(ctx=ctx) test_instance = self.create_instance_for_checking() ec2_client = connection.EC2ConnectionClient().client() reservation = ec2_client.run_instances( TEST_AMI_IMAGE_ID, instance_type=TEST_INSTANCE_TYPE) ctx.instance.runtime_properties['aws_resource_id'] = \ reservation.instances[0].id property_name = 'private_dns_name' dns_name = test_instance._get_instance_attribute(property_name) self.assertRegexpMatches(dns_name, FQDN)
def test_create_existing(self): """This tests that create creates the runtime_properties""" test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_create_duplicate', test_properties) current_ctx.set(ctx=ctx) name = ctx.node.properties.get('resource_id') description = ctx.node.properties.get('description') ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group(name, description) ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = group.id securitygroup.create(ctx=ctx) self.assertEqual( ctx.instance.runtime_properties['aws_resource_id'], group.id)
def test_validation_no_external_resource_is(self): """ this tests that creation_validation raises an error when a use_external_resource is false but a good instance_id is given. """ ctx = self.mock_ctx('test_validation_no_external_resource_is') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() reservation = ec2_client.run_instances( TEST_AMI_IMAGE_ID, instance_type=TEST_INSTANCE_TYPE) instance_id = reservation.instances[0].id ctx.node.properties['use_external_resource'] = False ctx.node.properties['resource_id'] = instance_id ex = self.assertRaises(NonRecoverableError, instance.creation_validation, ctx=ctx) self.assertIn('Not external resource, but the supplied', ex.message)
def test_terminate_clean(self): """ this tests that the instance.terminate function terminates the instance """ ctx = self.mock_ctx('test_terminate_clean') current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() reservation = ec2_client.run_instances( TEST_AMI_IMAGE_ID, instance_type=TEST_INSTANCE_TYPE) instance_id = reservation.instances[0].id ctx.instance.runtime_properties['aws_resource_id'] = instance_id instance.Instance().delete(ctx=ctx) reservations = ec2_client.get_all_reservations(instance_id) instance_object = reservations[0].instances[0] state = instance_object.update() self.assertEqual(state, 'terminated')
def test_delete_existing(self): """This tests that security group delete removed the runtime_properties """ test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_delete_existing', test_properties) current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group('test_delete_existing', 'this is test') ctx.node.properties['use_external_resource'] = True ctx.node.properties['resource_id'] = group.id ctx.instance.runtime_properties['aws_resource_id'] = group.id securitygroup.delete(ctx=ctx) self.assertNotIn( 'aws_resource_id', ctx.instance.runtime_properties)
def test_delete_deleted(self): """This tests that security group delete raises an error when the group is already deleted. """ test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_delete_deleted', test_properties) current_ctx.set(ctx=ctx) ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group('test_delete_deleted', 'this is test') ctx.instance.runtime_properties['aws_resource_id'] = group.id ec2_client.delete_security_group(group_id=group.id) ex = self.assertRaises( NonRecoverableError, securitygroup.delete, ctx=ctx) self.assertIn('Cannot use_external_resource because resource', ex.message)
def test_create_group_rules_no_src_group_id_or_cidr(self): """ This tests that either src_group_id or cidr_ip is error is raised when both are given. """ ec2_client = connection.EC2ConnectionClient().client() test_properties = self.get_mock_properties() ctx = self.security_group_mock( 'test_create_group_rules_no_src_group_id_or_cidr', test_properties) current_ctx.set(ctx=ctx) test_securitygroup = self.create_sg_for_checking() del ctx.node.properties['rules'][0]['cidr_ip'] group = ec2_client.create_security_group( 'test_create_group_rules_no_src_group_id_or_cidr', 'this is test') ex = self.assertRaises(NonRecoverableError, test_securitygroup._create_group_rules, group) self.assertIn('is not a valid rule target cidr_ip or src_group_ip', ex.message)
def test_creation_validation_not_existing(self): """This tests that when use_external_resource is false if such a security group exists an error is raised. """ test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_creation_validation_not_existing', test_properties) current_ctx.set(ctx=ctx) ctx.node.properties['use_external_resource'] = False ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group( 'test_creation_validation_not_existing', 'this is a test') ctx.node.properties['resource_id'] = group.id ex = self.assertRaises(NonRecoverableError, securitygroup.creation_validation, ctx=ctx) self.assertIn('Not external resource, but the supplied group', ex.message)
def test_create_retry(self): """This tests that create retry works""" test_properties = self.get_mock_properties() ctx = self.security_group_mock('test_create_retry', test_properties, retry_number=1) current_ctx.set(ctx=ctx) name = ctx.node.properties.get('resource_id') description = ctx.node.properties.get('description') ec2_client = connection.EC2ConnectionClient().client() group = ec2_client.create_security_group(name, description) ctx.instance.runtime_properties[constants.EXTERNAL_RESOURCE_ID] = \ group.id with mock.patch( 'cloudify_aws.ec2.securitygroup.' 'SecurityGroup.get_resource_state') as securitygroup_state: securitygroup_state.return_value = 'available' securitygroup.create(ctx=ctx)