def testUpWithEC2EnvironmentVariables(self):
# if the user wants us to use their EC2 credentials when running AppScale,
# we should make sure they get set
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'min' : 1,
'max' : 1,
'EC2_ACCESS_KEY' : 'access key',
'EC2_SECRET_KEY' : 'secret key'
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, pretend that our ec2 image to use exists
fake_ec2 = flexmock(name="fake_ec2")
fake_ec2.should_receive('get_image').with_args('ami-ABCDEFG') \
.and_return()
flexmock(boto)
boto.should_receive('connect_ec2').with_args('access key', 'secret key') \
.and_return(fake_ec2)
# finally, mock out the actual appscale-run-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('run_instances')
appscale.up()
self.assertEquals('access key', os.environ['EC2_ACCESS_KEY'])
self.assertEquals('secret key', os.environ['EC2_SECRET_KEY'])
def testDestroyWithEC2EnvironmentVariables(self):
# if the user wants us to use their EC2 credentials when running AppScale,
# we should make sure they get set
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'min' : 1,
'max' : 1,
'EC2_ACCESS_KEY' : 'access key',
'EC2_SECRET_KEY' : 'secret key'
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-terminate-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('terminate_instances')
appscale.destroy()
self.assertEquals('access key', os.environ['EC2_ACCESS_KEY'])
self.assertEquals('secret key', os.environ['EC2_SECRET_KEY'])
def testDeployWithCloudAppScalefile(self):
# calling 'appscale deploy app' with an AppScalefile in the local
# directory should collect any parameters needed for the
# 'appscale-upload-app' command and then exec it
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-run-instances call
fake_port = 8080
fake_host = 'fake_host'
flexmock(AppScaleTools)
AppScaleTools.should_receive('upload_app').and_return(
(fake_host, fake_port))
app = '/bar/app'
(host, port) = appscale.deploy(app)
self.assertEquals(fake_host, host)
self.assertEquals(fake_port, port)
def testCleanInClusterDeployment(self):
# calling 'appscale clean' in a cluster deployment should ssh into each of
# the boxes specified in the ips_layout and run the terminate script
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'ips_layout' : {
'controller': 'public1',
'servers': ['public2', 'public3']
},
'test' : True
}
yaml_dumped_contents = yaml.dump(contents)
flexmock(RemoteHelper)
RemoteHelper.should_receive('ssh') \
.with_args(re.compile('public[123]'), 'appscale', str, False)
flexmock(LocalState)
LocalState.should_receive('cleanup_appscale_files').with_args('appscale')
appscale = AppScale()
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
expected = ['public1', 'public2', 'public3']
self.assertEquals(expected, appscale.clean())
def testDeployWithCloudAppScalefileAndTestFlag(self):
# same as before, but with the 'test' flag in our AppScalefile
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1,
'test' : True
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-run-instances call
fake_port = 8080
fake_host = 'fake_host'
flexmock(AppScaleTools)
AppScaleTools.should_receive('upload_app').and_return(
(fake_host, fake_port))
app = '/bar/app'
(host, port) = appscale.deploy(app)
self.assertEquals(fake_host, host)
self.assertEquals(fake_port, port)
def testUndeployWithCloudAppScalefile(self):
# calling 'appscale undeploy app' with an AppScalefile in the local
# directory should collect any parameters needed for the
# 'appscale-remove-app' command and then exec it
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-run-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('remove_app')
app = 'barapp'
appscale.undeploy(app)
def testTailWithIndexInBounds(self):
# calling 'appscale tail 1 *' should tail from the second node
# (nodes[1]). If there are two nodes in this deployment,
# we should tail from it successfully
appscale = AppScale()
contents = { 'keyname' : 'boo' }
yaml_dumped_contents = yaml.dump(contents)
one = {
'public_ip' : 'blarg'
}
two = {
'public_ip' : 'blarg2'
}
nodes = [one, two]
nodes_contents = json.dumps(nodes)
mock = self.addMockForAppScalefile(appscale, yaml_dumped_contents)
(mock.should_receive('open')
.with_args(appscale.get_locations_json_file('boo'))
.and_return(flexmock(read=lambda: nodes_contents)))
flexmock(subprocess)
subprocess.should_receive('call').with_args(["ssh", "-o",
"StrictHostkeyChecking=no", "-i", appscale.get_key_location('boo'),
"root@blarg2", "tail -f /var/log/appscale/c*"]).and_return().once()
appscale.tail(1, "c*")
def testUpWithCloudAppScalefile(self):
# calling 'appscale up' if there is an AppScalefile present
# should call appscale-run-instances with the given config
# params. here, we assume that the file is intended for use
# on EC2
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# throw in some mocks for the argument parsing
for credential in EC2Agent.REQUIRED_CREDENTIALS:
os.environ[credential] = "baz"
# finally, pretend that our ec2 image to use exists
fake_ec2 = flexmock(name="fake_ec2")
fake_ec2.should_receive('get_image').with_args('ami-ABCDEFG') \
.and_return()
flexmock(boto)
boto.should_receive('connect_ec2').with_args('baz', 'baz').and_return(fake_ec2)
# finally, mock out the actual appscale-run-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('run_instances')
appscale.up()
def get_key_name(self):
"""
read key name from AppScalefile, which is by default believed in the current working directory.
"""
appscale = AppScale()
contents = appscale.read_appscalefile()
contents_as_yaml = yaml.safe_load(contents)
if "keyname" in contents_as_yaml:
return contents_as_yaml["keyname"]
else:
print "No keyname found in AppScalefile...Abort\n"
def testGetLogsWithNoKeyname(self):
# calling 'appscale logs dir' with no keyname should produce
# a command to exec without the --keyname flag
appscale = AppScale()
contents = {
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# mock out the actual call to appscale-gather-logs
flexmock(AppScaleTools)
AppScaleTools.should_receive('run_instances')
appscale.logs('/baz')
def testTailWithNoNodesJson(self):
# calling 'appscale tail' when there isn't a locations.json
# file should throw up and die
appscale = AppScale()
contents = { 'keyname' : 'boo' }
yaml_dumped_contents = yaml.dump(contents)
mock = self.addMockForAppScalefile(appscale, yaml_dumped_contents)
(mock.should_receive('open')
.with_args(appscale.get_locations_json_file('boo'))
.and_raise(IOError))
self.assertRaises(AppScaleException, appscale.tail, 0, "")
def testInitWithNoAppScalefile(self):
# calling 'appscale init cloud' if there's no AppScalefile in the local
# directory should write a new cloud config file there
appscale = AppScale()
flexmock(os)
os.should_receive('getcwd').and_return('/boo').once()
flexmock(os.path)
os.path.should_receive('exists').with_args('/boo/' + appscale.APPSCALEFILE).and_return(False).once()
# mock out the actual writing of the template file
flexmock(shutil)
shutil.should_receive('copy').with_args(appscale.TEMPLATE_CLOUD_APPSCALEFILE, '/boo/' + appscale.APPSCALEFILE).and_return().once()
appscale.init('cloud')
def testUpWithEC2EnvironmentVariables(self):
# if the user wants us to use their EC2 credentials when running AppScale,
# we should make sure they get set
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'min' : 1,
'max' : 1,
'EC2_ACCESS_KEY' : 'access key',
'EC2_SECRET_KEY' : 'secret key',
'zone' : 'my-zone-1b'
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
flexmock(os.path)
os.path.should_call('exists')
os.path.should_receive('exists').with_args(
'/boo/' + appscale.APPSCALEFILE).and_return(True)
# finally, pretend that our ec2 zone/image to use exist
fake_ec2 = flexmock(name="fake_ec2")
fake_ec2.should_receive('get_all_instances')
fake_ec2.should_receive('get_all_zones').with_args('my-zone-1b') \
.and_return('anything')
fake_ec2.should_receive('get_image').with_args('ami-ABCDEFG') \
.and_return()
flexmock(boto.ec2)
boto.ec2.should_receive('connect_to_region').with_args('my-zone-1',
aws_access_key_id='access key',
aws_secret_access_key='secret key').and_return(fake_ec2)
# finally, mock out the actual appscale-run-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('run_instances')
appscale.up()
self.assertEquals('access key', os.environ['EC2_ACCESS_KEY'])
self.assertEquals('secret key', os.environ['EC2_SECRET_KEY'])
def testTailWithIndexOutOfBounds(self):
# calling 'appscale tail 1 *' should tail from the second node
# (nodes[1]). If there's only one node in this deployment,
# we should throw up and die
appscale = AppScale()
contents = { 'keyname' : 'boo' }
yaml_dumped_contents = yaml.dump(contents)
one = {
'public_ip' : 'blarg'
}
nodes = [one]
nodes_contents = json.dumps(nodes)
mock = self.addMockForAppScalefile(appscale, yaml_dumped_contents)
(mock.should_receive('open')
.with_args(appscale.get_locations_json_file('boo'))
.and_return(flexmock(read=lambda: nodes_contents)))
self.assertRaises(AppScaleException, appscale.tail, 1, '')
def testTailWithIndexInBounds(self):
# calling 'appscale tail 1 *' should tail from the second node
# (nodes[1]). If there are two nodes in this deployment,
# we should tail from it successfully
appscale = AppScale()
contents = { 'keyname' : 'boo' }
yaml_dumped_contents = yaml.dump(contents)
one = {
'public_ip' : 'blarg'
}
two = {
'public_ip' : 'blarg2'
}
nodes = [one, two]
nodes_contents = json.dumps(nodes)
mock = self.addMockForAppScalefile(appscale, yaml_dumped_contents)
(mock.should_receive('open')
.with_args(appscale.get_locations_json_file('boo'))
.and_return(flexmock(read=lambda: nodes_contents)))
flexmock(subprocess)
subprocess.should_receive('call').with_args(["ssh", "-o",
"StrictHostkeyChecking=no", "-i", appscale.get_key_location('boo'),
"root@blarg2", "tail -F /var/log/appscale/c*"]).and_return().once()
appscale.tail(1, "c*")
def testUpWithClusterAppScalefile(self):
# calling 'appscale up' if there is an AppScalefile present
# should call appscale-run-instances with the given config
# params. here, we assume that the file is intended for use
# on a virtualized cluster
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'ips_layout': {
'master': 'ip1',
'appengine': 'ip1',
'database': 'ip2',
'zookeeper': 'ip2'
},
'keyname': 'boobazblarg'
}
yaml_dumped_contents = yaml.dump(contents)
base64_ips_layout = base64.b64encode(yaml.dump(contents["ips_layout"]))
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# for this test, let's say that we don't have an SSH key already
# set up for ip1 and ip2
# TODO(cgb): Add in tests where we have a key for ip1 but not ip2,
# and the case where we have a key but it doesn't work
flexmock(os.path)
key_path = os.path.expanduser('~/.appscale/boobazblarg.key')
os.path.should_call('exists')
os.path.should_receive('exists').with_args(key_path).and_return(
False).once()
# finally, mock out the actual appscale tools calls. since we're running
# via a cluster, this means we call add-keypair to set up SSH keys, then
# run-instances to start appscale
flexmock(AppScaleTools)
AppScaleTools.should_receive('add_keypair')
AppScaleTools.should_receive('run_instances')
appscale.up()
def testInitWithAppScalefile(self):
# calling 'appscale init cloud' if there is an AppScalefile in the local
# directory should throw up and die
appscale = AppScale()
flexmock(os)
os.should_receive('getcwd').and_return('/boo').once()
flexmock(os.path)
os.path.should_receive('exists').with_args(
'/boo/' + appscale.APPSCALEFILE).and_return(True).once()
self.assertRaises(AppScalefileException, appscale.init, 'cloud')
def testUpWithClusterAppScalefile(self):
# calling 'appscale up' if there is an AppScalefile present
# should call appscale-run-instances with the given config
# params. here, we assume that the file is intended for use
# on a virtualized cluster
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'ips_layout': {'master': 'ip1', 'appengine': 'ip1',
'database': 'ip2', 'zookeeper': 'ip2'},
'keyname': 'boobazblarg',
'group': 'boobazblarg'
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
flexmock(os.path)
os.path.should_call('exists')
os.path.should_receive('exists').with_args(
'/boo/' + appscale.APPSCALEFILE).and_return(True)
# for this test, let's say that we don't have an SSH key already
# set up for ip1 and ip2
# TODO(cgb): Add in tests where we have a key for ip1 but not ip2,
# and the case where we have a key but it doesn't work
key_path = os.path.expanduser('~/.appscale/boobazblarg.key')
os.path.should_receive('exists').with_args(key_path).and_return(False)
# finally, mock out the actual appscale tools calls. since we're running
# via a cluster, this means we call add-keypair to set up SSH keys, then
# run-instances to start appscale
flexmock(AppScaleTools)
AppScaleTools.should_receive('add_keypair')
AppScaleTools.should_receive('run_instances')
appscale.up()
def testGetLogsWithKeyname(self):
# calling 'appscale logs dir' with a keyname should produce
# a command to exec with the --keyname flag
appscale = AppScale()
contents = {
"keyname" : "boo"
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# mock out the actual call to appscale-gather-logs
flexmock(AppScaleTools)
AppScaleTools.should_receive('run_instances')
self.assertRaises(BadConfigurationException, appscale.logs, '/baz')
def testDestroyWithCloudAppScalefile(self):
# calling 'appscale destroy' with an AppScalefile in the local
# directory should collect any parameters needed for the
# 'appscale-terminate-instances' command and then exec it
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-terminate-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('terminate_instances')
appscale.destroy()
def testSetPropertyWithAppScalefile(self):
# calling 'appscale set' with an AppScalefile in the local
# directory should collect any parameters needed for the
# 'appscale-get-property' command and then exec it
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-set-property call
flexmock(AppScaleTools)
AppScaleTools.should_receive('set_property')
appscale.set('key', 'value')
def testUpWithCloudAppScalefile(self):
# calling 'appscale up' if there is an AppScalefile present
# should call appscale-run-instances with the given config
# params. here, we assume that the file is intended for use
# on EC2
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure': 'ec2',
'machine': 'ami-ABCDEFG',
'keyname': 'bookey',
'group': 'boogroup',
'min': 1,
'max': 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# throw in some mocks for the argument parsing
for credential in EC2Agent.REQUIRED_CREDENTIALS:
os.environ[credential] = "baz"
# finally, pretend that our ec2 image to use exists
fake_ec2 = flexmock(name="fake_ec2")
fake_ec2.should_receive('get_image').with_args('ami-ABCDEFG') \
.and_return()
flexmock(boto)
boto.should_receive('connect_ec2').with_args(
'baz', 'baz').and_return(fake_ec2)
# finally, mock out the actual appscale-run-instances call
flexmock(AppScaleTools)
AppScaleTools.should_receive('run_instances')
appscale.up()
def testSetPropertyWithAppScalefile(self):
# calling 'appscale set' with an AppScalefile in the local
# directory should collect any parameters needed for the
# 'appscale-get-property' command and then exec it
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale-set-property call
flexmock(AppScaleTools)
AppScaleTools.should_receive('set_property')
appscale.set('key', 'value')
def test_register(self):
appscale_yaml = {'keyname': 'boo'}
deployment = {
'name': 'bar',
'deployment_id': 'baz',
'nodes': [{'public_ip': 'public1', 'jobs': ['shadow']}]
}
flexmock(AppScale).should_receive('read_appscalefile')\
.and_return(yaml.dump(appscale_yaml))
flexmock(yaml).should_receive('safe_load').and_return({'keyname': 'boo'})
flexmock(AppScale).should_receive('get_nodes')\
.and_return(deployment['nodes'])
flexmock(AppScale).should_receive('get_head_node')\
.and_return(deployment['nodes'][0])
flexmock(RegistrationHelper).should_receive('update_deployment') \
.and_return(deployment)
flexmock(RegistrationHelper).should_receive('set_deployment_id') \
.and_return()
appscale = AppScale()
# If the deployment already has an ID and it differs from the one given,
# the tools should raise an AppScaleException.
existing_deployment_id = 'blarg'
flexmock(RegistrationHelper).should_receive('appscale_has_deployment_id')\
.and_return(True)
flexmock(RegistrationHelper).should_receive('get_deployment_id')\
.and_return(existing_deployment_id)
with self.assertRaises(AppScaleException):
appscale.register(deployment['deployment_id'])
# If the existing deployment ID is the same as the given deployment ID,
# the tools should try to complete the registration with the portal.
existing_deployment_id = 'baz'
flexmock(RegistrationHelper).should_receive('get_deployment_id') \
.and_return(existing_deployment_id)
appscale.register(deployment['deployment_id'])
# If the deployment does not have an ID set, the tools should try to
# complete the registration.
flexmock(RegistrationHelper).should_receive('appscale_has_deployment_id')\
.and_return(False)
appscale.register(deployment['deployment_id'])
def testCleanInCloudDeployment(self):
# calling 'appscale clean' in a cloud deployment should throw up and die
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file
contents = {
'infrastructure' : 'ec2',
'machine' : 'ami-ABCDEFG',
'keyname' : 'bookey',
'group' : 'boogroup',
'verbose' : True,
'min' : 1,
'max' : 1
}
yaml_dumped_contents = yaml.dump(contents)
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
self.assertRaises(BadConfigurationException, appscale.clean)
def test_get_nodes(self):
appscale = flexmock(AppScale())
builtin = flexmock(sys.modules['__builtin__'])
builtin.should_call('open')
nodes = [{'public_ip': 'blarg'}]
appscale_yaml = {'keyname': 'boo'}
appscale.should_receive('get_locations_json_file').\
and_return('locations.json')
# If the locations JSON file exists, it should return the locations as a
# dictionary.
builtin.should_receive('open').with_args('locations.json').\
and_return(flexmock(read=lambda: json.dumps(nodes)))
self.assertEqual(nodes, appscale.get_nodes(appscale_yaml['keyname']))
# If the locations JSON file does not exist, it should throw an
# AppScaleException.
builtin.should_receive('open').with_args('locations.json').\
and_raise(IOError)
with self.assertRaises(AppScaleException):
appscale.get_nodes(appscale_yaml['keyname'])
def testUpWithMalformedClusterAppScalefile(self):
# if we try to use an IPs layout that isn't a dictionary, we should throw up
# and die
appscale = AppScale()
# Mock out the actual file reading itself, and slip in a YAML-dumped
# file, with an IPs layout that is a str
contents = {
'ips_layout': "'master' 'ip1' 'appengine' 'ip1'",
'keyname': 'boobazblarg'
}
yaml_dumped_contents = yaml.dump(contents)
base64_ips_layout = base64.b64encode(yaml.dump(contents["ips_layout"]))
self.addMockForAppScalefile(appscale, yaml_dumped_contents)
# finally, mock out the actual appscale tools calls. since we're running
# via a cluster, this means we call add-keypair to set up SSH keys, then
# run-instances to start appscale
flexmock(AppScaleTools)
AppScaleTools.should_receive('add_keypair')
self.assertRaises(BadConfigurationException, appscale.up)
def testUpWithNoAppScalefile(self): # calling 'appscale up' if there is no AppScalefile present # should throw up and die appscale = AppScale() self.addMockForNoAppScalefile(appscale) self.assertRaises(AppScalefileException, appscale.up)
def testSshWithNotIntArg(self): # calling 'appscale ssh not-int' should throw up and die appscale = AppScale() self.addMockForAppScalefile(appscale, "") self.assertRaises(TypeError, appscale.ssh, "boo")
def testTailWithNotIntArg(self): # calling 'appscale tail not-int *' should throw up and die appscale = AppScale() self.addMockForAppScalefile(appscale, "") self.assertRaises(TypeError, appscale.tail, "boo", "")
def testRelocateWithNoAppScalefile(self): # calling 'appscale relocate' with no AppScalefile in the local directory # should throw up and die appscale = AppScale() self.addMockForNoAppScalefile(appscale) self.assertRaises(AppScalefileException, appscale.relocate, 'myapp', 80, 443)
def testCleanWithNoAppScalefile(self): # calling 'appscale clean' with no AppScalefile in the local # directory should throw up and die appscale = AppScale() self.addMockForNoAppScalefile(appscale) self.assertRaises(AppScalefileException, appscale.clean)
def testSetPropertyWithNoAppScalefile(self): # calling 'appscale set' with no AppScalefile in the local directory # should throw up and die appscale = AppScale() self.addMockForNoAppScalefile(appscale) self.assertRaises(AppScalefileException, appscale.set, 'key', 'value')
