def test_create_all(self):
if self.delete_project:
self.api.delete_project_role_and_policies()
assert self.api.code_build.project_exists() is False
assert self.api.code_build.iam.role_exists() is False
expected_account_id = '311800962295'
expected_project_arn = f'arn:aws:codebuild:{self.region}:{self.account_id}:project/{self.project_name}'
expected_build_id_start = f'arn:aws:codebuild:{self.region}:{self.account_id}:build/{self.project_name}'
Assert(self.account_id).is_equal(
expected_account_id
) # confirm account was correctly set from profile_name
Assert(self.api.project_name).is_equal(
self.project_name) # confirm vars setup
Assert(self.api.project_repo).is_equal(
f'https://github.com/{self.github_org}/{self.project_name}'
) # confirm repo
policies = self.api.policies__for_docker_build()
self.api.create_role_and_policies(policies)
sleep(1) # to give time for AWS to sync up internally
# todo: figure out why the next line fails due to the AWS permission problem
# it is caused by some of IAM permissions not having been propagated
assert self.api.create_project_with_container__docker(
)['project']['arn'] == expected_project_arn
assert self.project_name in self.api.code_build.projects(
) # confirm project has been created
assert self.api.code_build.iam.role_exists(
) is True # confirm role has been created
assert self.api.code_build.build_start().startswith(
expected_build_id_start) # start build
def test_project_info(self):
project = self.code_build.project_info()
(
Assert(project).field_is_equal('arn' , project_arn )
.field_is_equal('name' , project_name)
.field_is_equal('serviceRole', service_role)
)
def test_user_info(self):
user = self.iam.user_info()
(
Assert(user).field_is_equal('Arn' , test_user_arn)
.field_is_equal('Path' , '/')
.field_is_equal('UserName', test_user)
)
assert self.iam.set_user_name('AAAA').user_info().get('error') is not None
def test_create_function(self):
role_arn = IAM_Role(self.lambda_name +
'__tmp_role').create_for__lambda().get('role_arn')
tmp_folder = Temp_Folder_With_Lambda_File(
self.lambda_name).create_temp_file()
(self.aws_lambda.set_role(role_arn).set_s3_bucket(
self.s3_bucket).set_s3_key(self.s3_key).set_folder_code(
tmp_folder.folder))
create_kwargs = self.aws_lambda.create_kwargs()
assert create_kwargs == {
'Code': {
'S3Bucket': self.s3_bucket,
'S3Key': self.s3_key
},
'FunctionName': self.lambda_name,
'Handler': self.lambda_name + '.run',
'MemorySize': 10240,
'PackageType': 'Zip',
'Role': role_arn,
'Runtime': 'python3.8',
'Tags': {},
'Timeout': 900,
'TracingConfig': {
'Mode': 'PassThrough'
}
}
assert self.aws_lambda.upload() is True
result = self.aws_lambda.create()
data = result.get('data')
name = result.get('name')
status = result.get('status')
assert status == 'ok'
assert name == self.lambda_name
expected_arn = 'arn:aws:lambda:{0}:{1}:function:{2}'.format(
self.region, self.account_id,
self.lambda_name) # expected arn value
(Assert(data).field_is_equal('CodeSize',
242) # confirm lambda creation details
.field_is_equal('FunctionArn', expected_arn).field_is_equal(
'FunctionName', self.lambda_name).field_is_equal(
'Handler', self.lambda_name + '.run').field_is_equal(
'MemorySize',
10240).field_is_equal('Role', role_arn).field_is_equal(
'Runtime', 'python3.8').field_is_equal(
'Timeout',
900).field_is_equal('TracingConfig', {
'Mode': 'PassThrough'
}).field_is_equal('Version', '$LATEST'))
assert self.aws_lambda.invoke() == 'hello None'
assert self.aws_lambda.delete() is True # confirm Lambda was deleted
def test_role_create(self):
self.iam.role_delete()
role = self.iam.role_create(policy_document)
(
Assert(role).field_is_equal('Arn' ,test_role_arn)
.field_is_equal('Path' ,'/')
.field_is_equal('RoleName' , test_role)
.field_is_equal('AssumeRolePolicyDocument', policy_document)
)
assert self.iam.role_arn() == test_role_arn
def test_create_for__code_build(self):
result = self.iam_role.create_for__code_build()
status = result.get('status')
data = result.get('data')
role_arn = result.get('role_arn')
role_name = result.get('role_name')
create_date = data.get('CreateDate')
del data['RoleId']
del data['CreateDate']
expected_service = 'codebuild.amazonaws.com'
expected_arn = 'arn:aws:iam::{0}:role/test_IAM_Role__temp_role'.format(
self.account_id)
expected_data = {
'Arn': expected_arn,
'AssumeRolePolicyDocument': {
'Statement': [{
'Action': 'sts:AssumeRole',
'Effect': 'Allow',
'Principal': {
'Service': expected_service
}
}]
},
'Path': '/',
'RoleName': 'test_IAM_Role__temp_role'
}
assert status == 'ok'
assert role_arn == expected_arn
assert role_name == self.temp_role_name
assert data == expected_data
Assert(create_date).is_today()
assert self.iam_role.create_for__code_build() == {
'data': 'role already exists',
'role_name': self.temp_role_name,
'role_arn': expected_arn,
'status': 'warning'
}
def test_all_builds_ids(self): # LONG running test
ids = list(self.code_build.all_builds_ids())
Assert(ids).size_is(100)
ids = list(self.code_build.all_builds_ids(use_paginator=True))
Assert(ids).is_bigger_than(1000)
def test_projects(self):
result = self.code_build.projects()
Assert(result).is_bigger_than(2).is_smaller_than(100)
def test_contains(self):
Assert('abcdef').contains('abc')
def test_regex_not_match(self):
Assert("aaaabbb").regex_not_match("cc*")
def test_size_is(self):
Assert([1, 2, 3, 4]).size_is(4)
def test_match_regex(self):
Assert("aaaabbb").match_regex("a*")
def test_is_equal(self):
Assert({'a': 42}).is_equal({'a': 42})
Assert("aaaabbb").is_equal("aaaabbb")
def test_is_smaller_than(self):
Assert([1, 2, 3, 4]).is_smaller_than(5)
Assert(4).is_smaller_than(5)
def test_is_bigger_than(self):
Assert([1, 2, 3, 4]).is_bigger_than(3)
Assert(4).is_bigger_than(3)
def test_field_is_equal(self):
Assert({'a': 42}).field_is_equal('a', 42)
def test_setup(self):
Assert(self.browser).is_class('API_Browser')
Assert(self.vis_js.web_root).contains(
'serverless-render/osbot_browser/web_root')
Assert(self.browser.sync__url()).is_equal('about:blank')
Dev.print(self.browser.sync__url())
def test_is_class(self):
Assert(self).is_class('test_Assert')