def test_deploy_service_name_conflict(self):
"""Raise an error if a service name conflicts with an existing service
"""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample", "beekeeper", logging.getLogger("deploy")
)
# deploy the service a second time to generate a name conflict
d = deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample", "beekeeper", logging.getLogger("deploy")
)
error = yield self.failUnlessFailure(d, ServiceStateNameInUse)
self.assertEqual(str(error), "Service name 'beekeeper' is already in use")
def test_deploy_service_name_conflict(self):
"""Raise an error if a service name conflicts with an existing service
"""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:sample", "beekeeper",
logging.getLogger("deploy"))
# deploy the service a second time to generate a name conflict
d = deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:sample", "beekeeper",
logging.getLogger("deploy"))
error = yield self.failUnlessFailure(d, ServiceStateNameInUse)
self.assertEqual(str(error),
"Service name 'beekeeper' is already in use")
def test_deploy(self):
"""Create service, and service unit on machine from charm"""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
"myblog", logging.getLogger("deploy"), ["cpu=123"])
topology = yield self.get_topology()
service_id = topology.find_service_with_name("myblog")
self.assertEqual(service_id, "service-%010d" % 0)
exists = yield self.client.exists("/services/%s" % service_id)
self.assertTrue(exists)
service_state_manager = ServiceStateManager(self.client)
service_state = yield service_state_manager.get_service_state("myblog")
charm_id = yield service_state.get_charm_id()
self.assertEquals(charm_id, "local:series/sample-2")
constraints = yield service_state.get_constraints()
expect_constraints = {
"arch": "amd64", "cpu": 123, "mem": 512,
"provider-type": "dummy", "ubuntu-series": "series"}
self.assertEquals(constraints, expect_constraints)
machine_ids = topology.get_machines()
self.assertEqual(
machine_ids,
["machine-%010d" % 0, "machine-%010d" % 1])
exists = yield self.client.exists("/machines/%s" % machine_ids[0])
self.assertTrue(exists)
unit_ids = topology.get_service_units(service_id)
self.assertEqual(unit_ids, ["unit-%010d" % 0])
exists = yield self.client.exists("/units/%s" % unit_ids[0])
self.assertTrue(exists)
def test_deploy_multiple_units(self):
"""Create service, and service unit on machine from charm"""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
"myblog", logging.getLogger("deploy"), [], num_units=5)
topology = yield self.get_topology()
service_id = topology.find_service_with_name("myblog")
self.assertEqual(service_id, "service-%010d" % 0)
exists = yield self.client.exists("/services/%s" % service_id)
self.assertTrue(exists)
# Verify standard placement policy - unit placed on a new machine
machine_ids = topology.get_machines()
self.assertEqual(
set(machine_ids),
set(["machine-%010d" % i for i in xrange(6)]))
for i in xrange(6):
self.assertTrue(
(yield self.client.exists("/machines/%s" % machine_ids[i])))
unit_ids = topology.get_service_units(service_id)
self.assertEqual(
set(unit_ids),
set(["unit-%010d" % i for i in xrange(5)]))
for i in xrange(5):
self.assertTrue(
(yield self.client.exists("/units/%s" % unit_ids[i])))
def test_deploy_multiple_units(self):
"""Create service, and service unit on machine from charm"""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config,
environment,
self.unbundled_repo_path,
"local:sample",
"myblog",
logging.getLogger("deploy"),
num_units=5)
topology = yield self.get_topology()
service_id = topology.find_service_with_name("myblog")
self.assertEqual(service_id, "service-%010d" % 0)
exists = yield self.client.exists("/services/%s" % service_id)
self.assertTrue(exists)
# Verify standard placement policy - unit placed on a new machine
machine_ids = topology.get_machines()
self.assertEqual(set(machine_ids),
set(["machine-%010d" % i for i in xrange(6)]))
for i in xrange(6):
self.assertTrue(
(yield self.client.exists("/machines/%s" % machine_ids[i])))
unit_ids = topology.get_service_units(service_id)
self.assertEqual(set(unit_ids),
set(["unit-%010d" % i for i in xrange(5)]))
for i in xrange(5):
self.assertTrue((yield
self.client.exists("/units/%s" % unit_ids[i])))
def test_deploy_reuses_machines(self):
"""Verify that if machines are not in use, deploy uses them."""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:mysql", None, logging.getLogger("deploy"))
yield deploy.deploy(self.config, environment,
self.unbundled_repo_path, "local:wordpress", None,
logging.getLogger("deploy"))
yield self.destroy_service("mysql")
yield self.destroy_service("wordpress")
yield deploy.deploy(self.config, environment,
self.unbundled_repo_path, "local:wordpress", None,
logging.getLogger("deploy"))
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:mysql", None, logging.getLogger("deploy"))
yield self.assert_machine_assignments("wordpress", [1])
yield self.assert_machine_assignments("mysql", [2])
def test_deploy_no_service_name_short_charm_name(self):
"""Uses charm name as service name if possible."""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:sample", None, logging.getLogger("deploy"))
service = yield ServiceStateManager(
self.client).get_service_state("sample")
self.assertEqual(service.service_name, "sample")
def test_deploy_no_service_name_short_charm_name(self):
"""Uses charm name as service name if possible."""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample", None, logging.getLogger("deploy")
)
service = yield ServiceStateManager(self.client).get_service_state("sample")
self.assertEqual(service.service_name, "sample")
def test_deploy_reuses_machines(self):
"""Verify that if machines are not in use, deploy uses them."""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:mysql",
None, logging.getLogger("deploy"), [])
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path,
"local:wordpress", None, logging.getLogger("deploy"), [])
yield self.destroy_service("mysql")
yield self.destroy_service("wordpress")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path,
"local:wordpress", None, logging.getLogger("deploy"), [])
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:mysql",
None, logging.getLogger("deploy"), [])
yield self.assert_machine_assignments("wordpress", [1])
yield self.assert_machine_assignments("mysql", [2])
def test_deploy_sends_environment(self):
"""Uses charm name as service name if possible."""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
None, logging.getLogger("deploy"), [])
env_state_manager = EnvironmentStateManager(self.client)
env_config = yield env_state_manager.get_config()
self.assertEquals(yaml.load(env_config.serialize("firstenv")),
yaml.load(self.config.serialize("firstenv")))
def test_deploy_sends_environment(self):
"""Uses charm name as service name if possible."""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:sample", None, logging.getLogger("deploy"))
env_state_manager = EnvironmentStateManager(self.client)
env_config = yield env_state_manager.get_config()
self.assertEquals(yaml.load(env_config.serialize("firstenv")),
yaml.load(self.config.serialize("firstenv")))
def test_deploy_adds_peer_relations(self):
"""Deploy automatically adds a peer relations."""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:riak", None, logging.getLogger("deploy"))
service_manager = ServiceStateManager(self.client)
service_state = yield service_manager.get_service_state("riak")
relation_manager = RelationStateManager(self.client)
relations = yield relation_manager.get_relations_for_service(
service_state)
self.assertEqual(len(relations), 1)
self.assertEqual(relations[0].relation_name, "ring")
def test_deploy_adds_peer_relations(self):
"""Deploy automatically adds a peer relations."""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:riak", None, logging.getLogger("deploy")
)
service_manager = ServiceStateManager(self.client)
service_state = yield service_manager.get_service_state("riak")
relation_manager = RelationStateManager(self.client)
relations = yield relation_manager.get_relations_for_service(service_state)
self.assertEqual(len(relations), 1)
self.assertEqual(relations[0].relation_name, "ring")
def test_deploy_with_bad_config(self):
"""Valid config options should be available to the deployed
service."""
config_file = self.makeFile(
yaml.dump(dict(otherservice=dict(application_file="foo"))))
environment = self.config.get("firstenv")
failure = deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
"myblog", logging.getLogger("deploy"), [], config_file)
error = yield self.assertFailure(failure, ServiceConfigValueError)
self.assertIn(
"Expected a YAML dict with service name ('myblog').", str(error))
def test_deploy_with_bad_config(self):
"""Valid config options should be available to the deployed
service."""
config_file = self.makeFile(
yaml.dump(dict(otherservice=dict(application_file="foo"))))
environment = self.config.get("firstenv")
failure = deploy.deploy(self.config, environment,
self.unbundled_repo_path,
"local:sample", "myblog",
logging.getLogger("deploy"), config_file)
error = yield self.assertFailure(failure, ServiceConfigValueError)
self.assertIn("Expected a YAML dict with service name ('myblog').",
str(error))
def test_deploy_upgrade(self):
"""A charm can be deployed and get the latest version"""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
"myblog", logging.getLogger("deploy"), [])
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
"myblog2", logging.getLogger("deploy"), [], upgrade=True)
services = ServiceStateManager(self.client)
service1 = yield services.get_service_state("myblog")
s1_charm_id = yield service1.get_charm_id()
service2 = yield services.get_service_state("myblog2")
s2_charm_id = yield service2.get_charm_id()
self.assertNotEqual(s1_charm_id, s2_charm_id)
charms = CharmStateManager(self.client)
charm1 = yield charms.get_charm_state(s1_charm_id)
charm2 = yield charms.get_charm_state(s2_charm_id)
self.assertEqual(charm1.revision + 1, charm2.revision)
def test_deploy_with_invalid_config(self):
"""Can't deploy with config that doesn't pass charm validation."""
config_file = self.makeFile(
yaml.dump(dict(myblog=dict(application_file="foo"))))
environment = self.config.get("firstenv")
failure = deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample",
"myblog", logging.getLogger("deploy"), [], config_file)
error = yield self.assertFailure(failure, ServiceConfigValueError)
self.assertIn(
"application_file is not a valid configuration option",
str(error))
yield self.assertFailure(
ServiceStateManager(self.client).get_service_state("myblog"),
ServiceStateNotFound)
def test_deploy_with_default_config(self):
"""Valid config options should be available to the deployed
service."""
environment = self.config.get("firstenv")
# Here we explictly pass no config file but the services
# associated config.yaml defines default which we expect to
# find anyway.
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:dummy",
"myblog", logging.getLogger("deploy"), [], None)
# Verify that options in the yaml are available as state after
# the deploy call (successfully applied)
service = yield ServiceStateManager(
self.client).get_service_state("myblog")
config = yield service.get_config()
self.assertEqual(config["title"], "My Title")
def test_deploy_with_default_config(self):
"""Valid config options should be available to the deployed
service."""
environment = self.config.get("firstenv")
# Here we explictly pass no config file but the services
# associated config.yaml defines default which we expect to
# find anyway.
yield deploy.deploy(self.config, environment,
self.unbundled_repo_path, "local:dummy", "myblog",
logging.getLogger("deploy"), None)
# Verify that options in the yaml are available as state after
# the deploy call (successfully applied)
service = yield ServiceStateManager(
self.client).get_service_state("myblog")
config = yield service.get_config()
self.assertEqual(config["title"], "My Title")
def test_deploy_upgrade_remote(self):
"""The upgrade option is invalid with a remote charm."""
repo = self.mocker.mock(RemoteCharmRepository)
repo.type
self.mocker.result("store")
resolve = self.mocker.replace("juju.control.deploy.resolve")
resolve("cs:sample", None, "series")
self.mocker.result((repo, CharmURL.infer("cs:sample", "series")))
repo.find(MATCH(lambda x: isinstance(x, CharmURL)))
self.mocker.result(CharmDirectory(self.sample_dir1))
self.mocker.replay()
environment = self.config.get("firstenv")
error = yield self.assertFailure(deploy.deploy(
self.config, environment, None, "cs:sample",
"myblog", logging.getLogger("deploy"), [], upgrade=True),
CharmError)
self.assertIn("Only local directory charms can be upgraded on deploy",
str(error))
def test_deploy_upgrade_bundle(self):
"""The upgrade option is invalid with a charm bundle."""
# bundle sample charms
output = self.capture_logging("deploy")
CharmDirectory(self.sample_dir1).make_archive(
os.path.join(self.bundled_repo_path, "series", "old.charm"))
CharmDirectory(self.sample_dir2).make_archive(
os.path.join(self.bundled_repo_path, "series", "new.charm"))
environment = self.config.get("firstenv")
error = yield self.assertFailure(
deploy.deploy(
self.config, environment,
self.bundled_repo_path, "local:sample",
"myblog", logging.getLogger("deploy"), [], upgrade=True),
CharmError)
self.assertIn("Searching for charm", output.getvalue())
self.assertIn("Only local directory charms can be upgraded on deploy",
str(error))
def test_deploy_with_config(self):
"""Valid config options should be available to the deployed
service."""
config_file = self.makeFile(
yaml.dump(dict(myblog=dict(outlook="sunny", username="******"))))
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment,
self.unbundled_repo_path, "local:dummy", "myblog",
logging.getLogger("deploy"), config_file)
# Verify that options in the yaml are available as state after
# the deploy call (successfully applied)
service = yield ServiceStateManager(
self.client).get_service_state("myblog")
config = yield service.get_config()
self.assertEqual(config["outlook"], "sunny")
self.assertEqual(config["username"], "tester01")
# a default value from the config.yaml
self.assertEqual(config["title"], "My Title")
def test_deploy_with_config(self):
"""Valid config options should be available to the deployed
service."""
config_file = self.makeFile(yaml.dump(dict(
myblog=dict(outlook="sunny",
username="******"))))
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:dummy",
"myblog", logging.getLogger("deploy"), [], config_file)
# Verify that options in the yaml are available as state after
# the deploy call (successfully applied)
service = yield ServiceStateManager(
self.client).get_service_state("myblog")
config = yield service.get_config()
self.assertEqual(config["outlook"], "sunny")
self.assertEqual(config["username"], "tester01")
# a default value from the config.yaml
self.assertEqual(config["title"], "My Title")
def test_deploy(self):
"""Create service, and service unit on machine from charm"""
environment = self.config.get("firstenv")
yield deploy.deploy(
self.config, environment, self.unbundled_repo_path, "local:sample", "myblog", logging.getLogger("deploy")
)
topology = yield self.get_topology()
service_id = topology.find_service_with_name("myblog")
self.assertEqual(service_id, "service-%010d" % 0)
exists = yield self.client.exists("/services/%s" % service_id)
self.assertTrue(exists)
machine_ids = topology.get_machines()
self.assertEqual(machine_ids, ["machine-%010d" % 0, "machine-%010d" % 1])
exists = yield self.client.exists("/machines/%s" % machine_ids[0])
self.assertTrue(exists)
unit_ids = topology.get_service_units(service_id)
self.assertEqual(unit_ids, ["unit-%010d" % 0])
exists = yield self.client.exists("/units/%s" % unit_ids[0])
self.assertTrue(exists)
def test_deploy(self):
"""Create service, and service unit on machine from charm"""
environment = self.config.get("firstenv")
yield deploy.deploy(self.config, environment, self.unbundled_repo_path,
"local:sample", "myblog",
logging.getLogger("deploy"))
topology = yield self.get_topology()
service_id = topology.find_service_with_name("myblog")
self.assertEqual(service_id, "service-%010d" % 0)
exists = yield self.client.exists("/services/%s" % service_id)
self.assertTrue(exists)
machine_ids = topology.get_machines()
self.assertEqual(
machine_ids,
["machine-%010d" % 0, "machine-%010d" % 1])
exists = yield self.client.exists("/machines/%s" % machine_ids[0])
self.assertTrue(exists)
unit_ids = topology.get_service_units(service_id)
self.assertEqual(unit_ids, ["unit-%010d" % 0])
exists = yield self.client.exists("/units/%s" % unit_ids[0])
self.assertTrue(exists)
