def test_import_package_error(self, mock_post, mock_build_opener):
# prepare
mock_build_opener.return_value.open.return_value.read.return_value = 'TOKEN'
prepared_response = Response()
prepared_response.status_code = 201
prepared_response._content = json.dumps(
{'Success': False, 'ErrorMessage': 'Fail to find Name script'})
mock_post.return_value = prepared_response
package_zip = self.fs.create_file('work//package.zip', contents='ZIP CONTENT')
# act
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
# verify
with self.assertRaisesRegexp(Exception, 'Fail to find Name script'):
client.import_package('work//package.zip')
mock_post.assert_called_once()
self.assertEqual(
'http://SERVER:9000/API/Package/ImportPackage',
mock_post.call_args[0][0],
)
self.assertEqual(
{'Authorization': 'Basic TOKEN'},
mock_post.call_args[1]['headers'],
)
file_object = mock_post.call_args[1]['files']['file'].get_object()
self.assertEqual(package_zip, file_object)
def test_import_package(self, mock_post, mock_build_opener):
# prepare
mock_build_opener.return_value.open.return_value.read.return_value = 'TOKEN'
prepared_response = Response()
prepared_response.status_code = 201
mock_post.return_value = prepared_response
package_zip = self.fs.create_file('work//package.zip',
contents='ZIP CONTENT')
# act
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS',
'Global')
client.import_package('work//package.zip')
# verify
mock_post.assert_called_once()
self.assertEqual(
'http://SERVER:9000/API/Package/ImportPackage',
mock_post.call_args[0][0],
)
self.assertEqual(
{'Authorization': 'Basic TOKEN'},
mock_post.call_args[1]['headers'],
)
file_object = mock_post.call_args[1]['files']['file'].get_object()
self.assertEqual(package_zip, file_object)
def _open_connection_to_quali_server(self, cloudshell_config, pbar, retry):
if retry == 0:
raise FatalError(
"Connection to CloudShell Server failed. Please make sure it is up and running properly."
)
try:
client = PackagingRestApiClient(
ip=cloudshell_config.host,
username=cloudshell_config.username,
port=cloudshell_config.port,
domain=cloudshell_config.domain,
password=cloudshell_config.password)
return client
except HTTPError as e:
if e.code == 401:
raise FatalError(
"Login to CloudShell failed. Please verify the credentials in the config"
)
raise FatalError(
"Connection to CloudShell Server failed. Please make sure it is up and running properly."
)
except:
self._increase_pbar(pbar, time_wait=CLOUDSHELL_RETRY_INTERVAL_SEC)
return self._open_connection_to_quali_server(
cloudshell_config, pbar, retry - 1)
def _open_connection_to_quali_server(host,
user,
password,
port,
domain,
retry=3):
if retry == 0:
raise Exception(
"Connection to CloudShell Server failed. Please make sure it is up and running properly."
)
try:
client = PackagingRestApiClient(ip=host,
username=user,
port=port,
domain=domain,
password=password)
return client
except HTTPError as e:
if e.code == 401:
raise Exception(
u"Login to CloudShell failed. Please verify the credentials in the config"
)
raise Exception(
"Connection to CloudShell Server failed. Please make sure it is up and running properly."
)
except:
return _open_connection_to_quali_server(host, user, password, port,
domain, retry - 1)
def test_get_installed_standards(self, mock_get, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
mock_get.return_value = Response()
mock_get.return_value._content = "[]" # hack - empty response content
mock_get.return_value.status_code = 200 # Ok
# Act
client.get_installed_standards()
# Assert
self.assertTrue(mock_get.called, 'Get should be called')
self.assertEqual(mock_get.call_args[0][0], 'http://SERVER:9000/API/Standards')
self.assertEqual(mock_get.call_args[1]['headers']['Authorization'], 'Basic TOKEN')
def test_delete_shell_success(self, mock_delete, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
mock_delete.return_value = Response()
mock_delete.return_value._content = "[]" # hack - empty response content
mock_delete.return_value.status_code = 200 # Ok
# Act
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
client.delete_shell("shell")
# Assert
self.assertTrue(mock_delete.called, 'Delete should be called')
self.assertEqual(mock_delete.call_args[0][0], 'http://SERVER:9000/API/Shells/shell')
self.assertEqual(mock_delete.call_args[1]['headers']['Authorization'], 'Basic TOKEN')
def test_update_shell_name_given(self, mock_put, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
self.fs.CreateFile('work//NutShell.zip', contents='ZIP CONTENT')
mock_put.return_value = Response()
mock_put.return_value.status_code = 200 # Ok
# Act
client.update_shell('work//NutShell.zip', 'my_amazing_shell')
# Assert
self.assertTrue(mock_put.called, 'Put should be called')
self.assertEqual(mock_put.call_args[0][0], 'http://SERVER:9000/API/Shells/my_amazing_shell')
self.assertEqual(mock_put.call_args[1]['headers']['Authorization'], 'Basic TOKEN') \
def test_export_package(self, mock_post, mock_build_opener):
# prepare
mock_build_opener.return_value.open.return_value.read.return_value = 'TOKEN'
prepared_response = Response()
prepared_response.status_code = 201
prepared_response._content = 'zip package content'
mock_post.return_value = prepared_response
# act
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
response = client.export_package(['topology_name'])
# verify
mock_post.assert_called_once_with(
'http://SERVER:9000/API/Package/ExportPackage',
headers={'Authorization': 'Basic TOKEN'},
data={'TopologyNames': ['topology_name']},
)
self.assertEqual(response, 'zip package content')
def install(self, package_name, config):
"""
Installs package according to cloudshell
:param package_name: Package name to install
:type package_name str
:param config: Configuration to be used for
:type config shellfoundry.models.install_config.InstallConfig
:return:
"""
host = config.host
port = config.port
username = config.username
password = config.password
domain = config.domain
package_full_path = os.path.join(os.getcwd(), "dist",
package_name + ".zip")
click.echo(
"Installing package {0} into CloudShell at http://{1}:{2}".format(
package_full_path, host, port))
server = PackagingRestApiClient(host, port, username, password, domain)
server.upload_environment_zip_file(package_full_path)
def test_login(self, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
# Act
PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
# Assert
self.assertTrue(mock_opener.open.called, 'open should be called')
def test_delete_shell_shell_not_found_raises_error(self, mock_delete, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
mock_delete.return_value = Response()
mock_delete.return_value.status_code = 400 # Bad Request
# Act Assert
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
self.assertRaises(ShellNotFoundException, client.delete_shell, 'shell')
def test_delete_shell_feature_unavailable_http_status_405_raises_error(self, mock_delete, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
mock_delete.return_value = Response()
mock_delete.return_value.status_code = 405 # Method Not Allowed
# Act Assert
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
self.assertRaises(FeatureUnavailable, client.delete_shell, 'shell')
def test_get_shell_feature_unavailable_raises_error(self, mock_get, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
mock_get.return_value = Response()
mock_get.return_value.status_code = 404 # Not Found
# Act Assert
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
self.assertRaises(FeatureUnavailable, client.get_shell, 'shell')
def test_get_installed_standards_feature_not_install_error_thrown(self, mock_get, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
mock_get.return_value = Response()
mock_get.return_value.status_code = 404 # Not Found
# Act Assert
self.assertRaises(FeatureUnavailable, client.get_installed_standards)
def _create_client(self):
try:
client = PackagingRestApiClient(ip=self._cs_config.host,
username=self._cs_config.username,
port=self._cs_config.port,
domain=self._cs_config.domain,
password=self._cs_config.password)
return client
except (HTTPError, Exception) as e:
if hasattr(e, 'code') and e.code == 401:
raise FatalError(
u'Login to CloudShell failed. Please verify the credentials in the config'
)
raise FatalError(self.ConnectionFailureMessage)
def _connect_to_cloudshell(cloudshell_config):
try:
client = PackagingRestApiClient(
ip=cloudshell_config.host,
username=cloudshell_config.username,
port=cloudshell_config.port,
domain=cloudshell_config.domain,
password=cloudshell_config.password)
return client
except urllib2.URLError:
click.echo(
u'Login to CloudShell failed. Please verify the credentials in cloudshell_config.yml',
err=True)
raise
def test_update_shell_throws_shell_not_found_exception_when_404_code_returned(self, mock_put, mock_build_opener):
# Arrange
mock_url = Mock()
mock_url.read = Mock(return_value='TOKEN')
mock_opener = Mock()
mock_opener.open = Mock(return_value=mock_url)
mock_build_opener.return_value = mock_opener
client = PackagingRestApiClient('SERVER', 9000, 'USER', 'PASS', 'Global')
self.fs.CreateFile('work//NutShell.zip', contents='ZIP CONTENT')
mock_put.return_value = Response()
mock_put.return_value.status_code = 404 # Not Found
# Act & Assert
self.assertRaises(ShellNotFoundException, client.update_shell, 'work//NutShell.zip')
def _rest_api(self) -> PackagingRestApiClient:
logger.debug("Connecting to REST API")
rest_api = PackagingRestApiClient(self.conf.host, 9000, self.conf.user,
self.conf.password, self.conf.domain)
logger.debug("Connected to REST API")
return rest_api
1. Edit blueprint in cloudshell GUI
2. Quali API to download blueprint
3. unzip package
4. copy over files in repo and commit
"""
import os
from credentials import cs_credentials
from cloudshell.rest.api import PackagingRestApiClient
import zipfile
TARGET_BLUEPRINT = "backup test"
api = PackagingRestApiClient(ip=cs_credentials["server"],
port=9000,
username=cs_credentials["user"],
password=cs_credentials["password"],
domain=cs_credentials["domain"])
# download from quali api to local repo
response_content = api.export_package([TARGET_BLUEPRINT])
package_name = TARGET_BLUEPRINT + "_package.zip"
with open(package_name, "wb") as target_file:
target_file.write(response_content)
curr_dir = os.getcwd()
package_path = os.path.join(curr_dir, package_name)
unzipped_dir = "{}_package_unzipped".format(TARGET_BLUEPRINT)
unzipped_path = os.path.join(curr_dir, unzipped_dir)
with zipfile.ZipFile(package_path, 'r') as zip_ref:
zip_ref.extractall(unzipped_path)
