class TestNoSourceControl(unittest.TestCase):
def setUp(self):
if not os.path.exists('testDir{}'.format(os.path.sep)):
os.makedirs('testDir{}'.format(os.path.sep))
os.chdir('testDir')
self.patcher_io = mock.patch('ebcli.objects.sourcecontrol.io')
self.mock_input = self.patcher_io.start()
def tearDown(self):
self.patcher_io.stop()
os.chdir(os.path.pardir)
if os.path.exists('testDir'):
shutil.rmtree('testDir')
@unittest.skipIf(fileoperations.program_is_installed('git'),
"Skipped because git is installed")
def test_get_source_control(self):
sc = sourcecontrol.SourceControl.get_source_control()
self.assertIsInstance(sc, sourcecontrol.NoSC)
def test_get_name(self):
self.assertEqual(sourcecontrol.NoSC().get_name(), None)
def test_get_current_branch(self):
self.assertEqual(sourcecontrol.NoSC().get_current_branch(), 'default')
@mock.patch('ebcli.objects.sourcecontrol.fileoperations')
def test_do_zip(self, mock_file):
sourcecontrol.NoSC().do_zip('file.zip')
mock_file.zip_up_project.assert_called_with('file.zip')
def is_setup(self):
if fileoperations.is_git_directory_present():
if not fileoperations.program_is_installed('git'):
raise CommandError(strings['sc.gitnotinstalled'])
else:
return True
return False
def is_setup(self):
if fileoperations.is_git_directory_present():
# We know that the directory has git, but
# is git on the path?
if not fileoperations.program_is_installed('git'):
raise CommandError(strings['sc.gitnotinstalled'])
else:
return True
return False
def is_setup(self):
if fileoperations.is_git_directory_present():
# We know that the directory has git, but
# is git on the path?
if not fileoperations.program_is_installed('git'):
raise CommandError(strings['sc.gitnotinstalled'])
else:
return True
return False
def should_prompt_customer_to_opt_into_codecommit(force_non_interactive,
region_name, source):
source_location, repository, branch = utils.parse_source(source)
if force_non_interactive:
return False
elif source_location and not codecommit.region_supported(region_name):
io.log_warning(strings['codecommit.badregion'])
return False
elif not fileoperations.is_git_directory_present():
io.echo(strings['codecommit.nosc'])
return False
elif not fileoperations.program_is_installed('git'):
io.echo(strings['codecommit.nosc'])
return False
elif directory_is_already_associated_with_a_branch():
return False
return True
def generate_self_signed_cert(cert_name):
home = fileoperations.get_home()
cert_dir = os.path.join(home, '.ssl')
privatekey_filename = cert_name + '-privatekey.pem'
privatekey_dir = os.path.join(cert_dir, privatekey_filename)
sign_request_filename = cert_name + '-csr.pem'
sign_request_dir = os.path.join(cert_dir, sign_request_filename)
server_cert_filename = cert_name + '.crt'
server_cert_dir = os.path.join(cert_dir, server_cert_filename)
if not os.path.isdir(cert_dir):
os.mkdir(cert_dir)
io.log_warning('Generating a self-signed certificate. '
'To provide an already created certificate, '
'use the command options.'
'\nSee "eb labs setup-ssl --help" for more info.')
if not fileoperations.program_is_installed('openssl'):
raise CommandError('This command requires openssl to be '
'installed on the PATH')
if not os.path.isfile(privatekey_dir):
utils.exec_cmd_quiet(['openssl', 'genrsa', '-out', privatekey_dir])
if not os.path.isfile(sign_request_dir):
io.echo()
subprocess.check_call([
'openssl', 'req', '-new', '-key', privatekey_dir, '-out',
sign_request_dir
])
io.echo()
if not os.path.isfile(server_cert_dir):
utils.exec_cmd_quiet([
'openssl', 'x509', '-req', '-days', '365', '-in', sign_request_dir,
'-signkey', privatekey_dir, '-out', server_cert_dir
])
return privatekey_dir, server_cert_dir
class TestGitSourceControl(unittest.TestCase):
def setUp(self):
if not os.path.exists('testDir{}'.format(os.path.sep)):
os.makedirs('testDir{}'.format(os.path.sep))
os.chdir('testDir')
fileoperations.create_config_file('testapp', 'us-east-1', 'PHP')
with open('myFile', 'w') as f:
f.write('Hello')
subprocess.call(['git', 'init'])
subprocess.call(
['git', 'config', '--local', 'user.email', '*****@*****.**'])
subprocess.call(['git', 'config', '--local', 'user.name', 'abc def'])
subprocess.call(['git', 'add', 'myFile'])
subprocess.call(['git', 'commit', '-m', 'Initial'])
with open('myFile2', 'w') as f:
f.write('Hello There')
subprocess.call(['git', 'add', 'myFile2'])
subprocess.call(['git', 'commit', '-m', 'Hello'])
subprocess.call(['git', 'tag', '-a', 'v1', '-m', 'my version'])
self.patcher_io = mock.patch('ebcli.objects.sourcecontrol.io')
self.mock_input = self.patcher_io.start()
def tearDown(self):
self.patcher_io.stop()
os.chdir(os.path.pardir)
if os.path.exists('testDir'):
if sys.platform.startswith('win'):
os.system('rmdir /S /Q testDir')
else:
shutil.rmtree('testDir')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_source_control(self):
sc = sourcecontrol.SourceControl.get_source_control()
self.assertIsInstance(sc, sourcecontrol.Git)
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_name(self):
self.assertEqual(sourcecontrol.Git().get_name(), 'git')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_current_branch(self):
self.assertEqual(sourcecontrol.Git().get_current_branch(), 'master')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_current_branch_detached_head(self):
subprocess.call(['git', 'checkout', 'HEAD^'])
self.assertEqual(sourcecontrol.Git().get_current_branch(), 'default')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_do_zip(self):
sourcecontrol.Git().do_zip(os.getcwd() + os.path.sep + 'file.zip')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_message(self):
self.assertEqual(sourcecontrol.Git().get_message(), 'Hello')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_version_label(self):
self.assertTrue(
sourcecontrol.Git().get_version_label().startswith('app-v1-'))
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_set_up_ignore_no_file(self):
self.assertFalse(os.path.isfile('.gitignore'))
sourcecontrol.Git().set_up_ignore_file()
self.assertTrue(os.path.isfile('.gitignore'))
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_set_up_ignore_file_file_exists(self):
with open('.gitignore', 'w') as f:
f.write('line1\n')
f.write('line2\n')
sourcecontrol.Git().set_up_ignore_file()
with open('.gitignore', 'r') as f:
f = f.readlines()
self.assertEqual(f[0], 'line1\n')
self.assertEqual(f[1], 'line2\n')
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
@mock.patch('ebcli.objects.sourcecontrol.exec_cmd')
def test_error_handler_for_exit_code_128(self, mock_exec_cmd):
stdout = ""
stderr = "Not a valid object name HEAD"
exit_code = 128
mock_exec_cmd.return_value = stdout, stderr, exit_code
self.assertRaises(CommandError, sourcecontrol.Git().get_version_label)
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
@mock.patch('ebcli.objects.sourcecontrol.exec_cmd')
def test_error_handler_for_exit_code_127(self, mock_exec_cmd):
stdout = ""
stderr = "git not installed"
exit_code = 127
mock_exec_cmd.return_value = stdout, stderr, exit_code
self.assertRaises(NoSourceControlError,
sourcecontrol.Git().get_version_label)
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
@mock.patch('ebcli.objects.sourcecontrol.exec_cmd')
def test_error_handler_for_non_handled_exit_code(self, mock_exec_cmd):
stdout = ""
stderr = "git not installed"
exit_code = 99999
mock_exec_cmd.return_value = stdout, stderr, exit_code
self.assertRaises(CommandError, sourcecontrol.Git().get_version_label)
@mock.patch.object(sourcecontrol.Git, '_run_cmd')
@mock.patch.object(sourcecontrol.Git, 'get_current_branch')
def test_get_current_repository_git_cmd_succeeded(
self,
get_current_branch_mock,
_run_cmd_mock,
):
get_current_branch_mock.return_value = 'develop'
_run_cmd_mock.return_value = 'develop-remote', '', 0
actual = sourcecontrol.Git().get_current_repository()
get_current_branch_mock.assert_called_once_with()
_run_cmd_mock.assert_called_once_with(
['git', 'config', '--get', 'branch.develop.remote'],
handle_exitcode=False)
self.assertEqual('develop-remote', actual)
@mock.patch.object(sourcecontrol.Git, '_run_cmd')
@mock.patch.object(sourcecontrol.Git, 'get_current_branch')
def test_get_current_repository__git_cmd_failed(
self,
get_current_branch_mock,
_run_cmd_mock,
):
get_current_branch_mock.return_value = 'develop'
_run_cmd_mock.return_value = '', 'error message', 1
actual = sourcecontrol.Git().get_current_repository()
get_current_branch_mock.assert_called_once_with()
_run_cmd_mock.assert_called_once_with(
['git', 'config', '--get', 'branch.develop.remote'],
handle_exitcode=False)
self.assertIsNone(actual)
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
def test_get_current_branch(self):
self.assertEqual('master', sourcecontrol.Git().get_current_branch())
@unittest.skipIf(not fileoperations.program_is_installed('git'),
"Skipped because git is not installed")
@mock.patch('ebcli.core.io.log_warning')
def test_get_current_branch__detached_head_state(self, log_warning_mock):
self.assertIsNotNone(sourcecontrol.Git().get_current_branch())
p = subprocess.Popen(['git', 'rev-parse', 'HEAD'],
stdout=subprocess.PIPE)
stdout, _ = p.communicate()
commit_of_head = stdout.decode().strip()
p = subprocess.Popen(['git', 'checkout', commit_of_head],
stdout=subprocess.PIPE)
p.communicate()
self.assertEqual('default', sourcecontrol.Git().get_current_branch())
def test_verify_url_is_a_codecommit_url__valid_urls(self):
valid_urls = [
'https://git-codecommit.us-east-1.amazonaws.com',
'https://git-codecommit.us-east-1.amazonaws.com/v1/repos/github-tests-test-1',
'https://git-codecommit.us-east-1.amazonaws.com.cn/v1/repos/github-tests-test-1',
'ssh://git-codecommit.us-east-1.amazonaws.com/v1/repos/github-tests-test-1',
'git-codecommit..amazonaws.com',
'git-codecommit.us-east-1.amazonaws.com/v1/repos/github-tests-test-1',
]
for url in valid_urls:
sourcecontrol.Git().verify_url_is_a_codecommit_url(url)
def test_verify_url_is_a_codecommit_url__invalid_urls(self):
invalid_urls = [
'https://github.us-east-1.amazonaws.com',
'ssh://git-codecommit.us-east-1.com/v1/repos/github-tests-test-1',
'https://github.com/rahulrajaram/dummy_repository.git',
'https://[email protected]/tutorials/tutorials.git.bitbucket.org.git',
'github..amazonaws.com',
]
for url in invalid_urls:
with self.assertRaises(NoSourceControlError) as context_manager:
sourcecontrol.Git().verify_url_is_a_codecommit_url(url)
self.assertEqual(
'Could not connect to repository located at {}'.format(url),
context_manager.exception.message)
def test_credential_helper_command(self):
self.assertEqual('!aws codecommit credential-helper $@',
sourcecontrol.credential_helper_command())
@mock.patch('ebcli.objects.sourcecontrol.Git._run_cmd')
def test_setup_codecommit_cred_config__non_windows(self, _run_cmd_mock):
sourcecontrol.Git().setup_codecommit_cred_config()
_run_cmd_mock.assert_has_calls([
mock.call([
'git', 'config', '--local', '--replace-all',
'credential.UseHttpPath', 'true'
]),
mock.call([
'git', 'config', '--local', '--replace-all',
'credential.helper', '!aws codecommit credential-helper $@'
])
])
@mock.patch.object(sourcecontrol.Git, '_run_cmd')
def test_fetch_remote_branches__git_cmd_succeded(self, _run_cmd_mock):
_run_cmd_mock.return_value = '', '', 0
actual = sourcecontrol.Git().fetch_remote_branches('develop')
_run_cmd_mock.assert_called_once_with(['git', 'fetch', 'develop'],
handle_exitcode=False)
self.assertTrue(actual)
@mock.patch.object(sourcecontrol.Git, '_run_cmd')
def test_fetch_remote_branches__git_cmd_failed(self, _run_cmd_mock):
_run_cmd_mock.return_value = '', '', 1
actual = sourcecontrol.Git().fetch_remote_branches('develop')
_run_cmd_mock.assert_called_once_with(['git', 'fetch', 'develop'],
handle_exitcode=False)
self.assertFalse(actual)
def is_boot2docker_installed():
return program_is_installed('boot2docker')
def test_program_is_installed(self, os_which_mock):
os_which_mock.return_value = '/Users/name/ebcli-virtaulenv/bin/eb'
self.assertTrue(fileoperations.program_is_installed('eb'))
def is_boot2docker_installed():
return program_is_installed('boot2docker')
def test_program_is_installed(self):
self.assertTrue(fileoperations.program_is_installed('eb'))
