def test_render_svg(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [],
status.renderers["svg"],
self.output,
None)
# look for a hint the process completed.
self.assertIn("</svg>", self.output.getvalue())
def test_render_svg(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [], status.renderers["svg"],
self.output, None)
#dump_stringio(self.output, "/tmp/ens.svg")
# look for a hint the process completed.
self.assertIn("</svg>", self.output.getvalue())
def test_subordinate_status_output(self):
state = yield self.build_topology()
# supplement status with additional subordinates
# add logging to mysql and wordpress
logging = yield self.add_service_from_charm("logging")
mysql_ep = RelationEndpoint("mysql", "client-server",
"juju-info", "server")
wordpress_db_ep = RelationEndpoint("wordpress", "client-server",
"juju-info", "server")
logging_ep = RelationEndpoint("logging", "client-server",
"juju-info", "client", "container")
my_log_rel, my_log_services = (
yield self.relation_state_manager.add_relation_state(
mysql_ep, logging_ep))
wp_log_rel, wp_log_services = (
yield self.relation_state_manager.add_relation_state(
wordpress_db_ep, logging_ep))
units = state["units"]
log_units = units.setdefault("logging", {})
wp1 = iter(units["wordpress"]).next()
mu1, mu2 = list(units["mysql"])
yield self.add_unit(logging, None, container=mu1, units=log_units)
yield self.add_unit(logging, None, container=wp1, units=log_units)
yield self.add_unit(logging, None, container=mu2, units=log_units)
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [],
status.render_yaml, self.output, None)
state = yaml.load(self.output.getvalue())
# verify our changes
log_state = state["services"]["logging"]
self.assertEqual(set(log_state["relations"]["juju-info"]),
set(["mysql", "wordpress"]))
self.assertEqual(set(log_state["subordinate-to"]),
set(["mysql", "wordpress"]))
wp_state = state["services"]["wordpress"]
self.assertEqual(wp_state["relations"]["juju-info"], ["logging"])
wp_subs = wp_state["units"]["wordpress/0"]["subordinates"]
logging_sub = wp_subs["logging/1"]
# this assertion verifies that we don't see keys we don't
# expect as well
self.assertEqual(logging_sub, {"agent-state": "pending"})
def test_render_dot(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [],
status.render_dot, self.output, None)
result = self.output.getvalue()
#dump_stringio(self.output, "/tmp/ens.dot")
# make mild assertions about the expected DOT output
# because the DOT language is simple we can test that some
# relationships are present
self.assertIn('memcache -> "memcache/1"', result)
self.assertIn('varnish -> "varnish/0"', result)
self.assertIn('varnish -> "varnish/1"', result)
# test that relationships are being rendered
self.assertIn("wordpress -> memcache", result)
self.assertIn("mysql -> wordpress", result)
# assert that properties were applied to a relationship
# self.assertIn("wordpress -> varnish [dir=none, "
# "label=\"varnish:wordpress/proxy\"]",
# result)
# verify that the renderer picked up the DNS name of the
# machines (and they are associated with the proper machine)
self.assertIn(
'"mysql/0" [color="#DD4814", fontcolor="#ffffff", '
"shape=box, style=filled, label=<mysql/0<br/><i>mysql-0."
"example.com</i>>]",
result)
self.assertIn(
'"mysql/1" [color="#DD4814", fontcolor="#ffffff", shape=box, style=filled, label=<mysql/1<br/><i>mysql-1.example.com</i>>]',
result)
# Check the charms are present in the service node.
self.assertIn(
'memcache [color="#772953", fontcolor="#ffffff", shape=component, style=filled, label=<memcache<br/>local:series/dummy-1>]', result)
self.assertIn(
'varnish [color="#772953", fontcolor="#ffffff", shape=component, style=filled, label=<varnish<br/>local:series/varnish-1>]',result)
self.assertIn(
'mysql [color="#772953", fontcolor="#ffffff", shape=component, style=filled, label=<mysql<br/>local:series/mysql-1>]', result)
self.assertIn("local:series/dummy-1", result)
def test_render_dot(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [], status.render_dot,
self.output, None)
result = self.output.getvalue()
#dump_stringio(self.output, "/tmp/ens.dot")
# make mild assertions about the expected DOT output
# because the DOT language is simple we can test that some
# relationships are present
self.assertIn('memcache -> "memcache/1"', result)
self.assertIn('varnish -> "varnish/0"', result)
self.assertIn('varnish -> "varnish/1"', result)
# test that relationships are being rendered
self.assertIn("wordpress -> memcache", result)
self.assertIn("mysql -> wordpress", result)
# assert that properties were applied to a relationship
self.assertIn("wordpress -> varnish [dir=none, label=proxy]", result)
# verify that the renderer picked up the DNS name of the
# machines (and they are associated with the proper machine)
self.assertIn(
'"mysql/0" [color="#DD4814", fontcolor="#ffffff", shape=box, style=filled, label=<mysql/0<br/><i>mysql-0.example.com</i>>]',
result)
self.assertIn(
'"mysql/1" [color="#DD4814", fontcolor="#ffffff", shape=box, style=filled, label=<mysql/1<br/><i>mysql-1.example.com</i>>]',
result)
# Check the charms are present in the service node.
self.assertIn(
'memcache [color="#772953", fontcolor="#ffffff", shape=component, style=filled, label=<memcache<br/>local:series/dummy-1>]',
result)
self.assertIn(
'varnish [color="#772953", fontcolor="#ffffff", shape=component, style=filled, label=<varnish<br/>local:series/varnish-1>]',
result)
self.assertIn(
'mysql [color="#772953", fontcolor="#ffffff", shape=component, style=filled, label=<mysql<br/>local:series/mysql-1>]',
result)
self.assertIn("local:series/dummy-1", result)
def test_render_yaml(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [], status.render_yaml,
self.output, None)
state = yaml.load(self.output.getvalue())
self.assertEqual(set(state["machines"].keys()),
set([0, 1, 2, 3, 4, 5, 6]))
services = state["services"]
self.assertEqual(set(services["memcache"].keys()),
set(["charm", "relations", "units"]))
self.assertEqual(set(services["mysql"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["varnish"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["wordpress"].keys()),
set(["charm", "relations", "units"]))
for service in services.itervalues():
self.assertGreaterEqual( # may also include "exposed" key
set(service.keys()), set(["units", "relations", "charm"]))
self.assertTrue(service["charm"].startswith("local:series/"))
self.assertEqual(
state["machines"][0], {
"instance-id": 0,
"instance-state": "unknown",
"dns-name": "steamcloud-1.com",
"state": "down"
})
self.assertEqual(services["mysql"]["relations"], {"db": "wordpress"})
self.assertEqual(services["mysql"]["units"]["mysql/1"]["open-ports"],
[])
self.assertEqual(services["wordpress"]["relations"], {
"cache": "memcache",
"db": "mysql",
"proxy": "varnish"
})
def test_render_yaml(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [],
status.render_yaml, self.output, None)
state = yaml.load(self.output.getvalue())
self.assertEqual(set(state["machines"].keys()),
set([0, 1, 2, 3, 4, 5, 6]))
services = state["services"]
self.assertEqual(set(services["memcache"].keys()),
set(["charm", "relations", "units"]))
self.assertEqual(set(services["mysql"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["varnish"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["wordpress"].keys()),
set(["charm", "relations", "units"]))
for service in services.itervalues():
self.assertGreaterEqual( # may also include "exposed" key
set(service.keys()),
set(["units", "relations", "charm"]))
self.assertTrue(service["charm"].startswith("local:series/"))
self.assertEqual(state["machines"][0],
{"instance-id": 0,
"instance-state": "unknown",
"dns-name": "steamcloud-1.com",
"state": "down"})
self.assertEqual(services["mysql"]["relations"],
{"db": "wordpress"})
self.assertEqual(services["mysql"]["units"]["mysql/1"]["open-ports"],
[])
self.assertEqual(services["wordpress"]["relations"],
{"cache": "memcache",
"db": "mysql",
"proxy": "varnish"})
def test_subordinate_status_output_no_container(self):
state = yield self.build_topology()
# supplement status with additional subordinates
# add logging to mysql and wordpress
logging = yield self.add_service_from_charm("logging")
mysql_ep = RelationEndpoint("mysql", "client-server",
"juju-info", "server")
wordpress_db_ep = RelationEndpoint("wordpress", "client-server",
"juju-info", "server")
logging_ep = RelationEndpoint("logging", "client-server",
"juju-info", "client", "container")
my_log_rel, my_log_services = (
yield self.relation_state_manager.add_relation_state(
mysql_ep, logging_ep))
wp_log_rel, wp_log_services = (
yield self.relation_state_manager.add_relation_state(
wordpress_db_ep, logging_ep))
units = state["units"]
log_units = units.setdefault("logging", {})
wp1 = iter(units["wordpress"]).next()
mu1, mu2 = list(units["mysql"])
yield self.add_unit(logging, None, container=mu1, units=log_units)
yield self.add_unit(logging, None, container=wp1, units=log_units)
yield self.add_unit(logging, None, container=mu2, units=log_units)
# remove mysql/0
yield state["services"]["mysql"].remove_unit_state(mu1)
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [],
status.render_yaml, self.output, None)
output = yaml.load(self.output.getvalue())
self.assertNotIn(mu1.unit_name, output["services"]["mysql"]["units"])
self.assertIn(mu2.unit_name, output["services"]["mysql"]["units"])
def test_render_json(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [],
status.render_json, self.output, None)
state = json.loads(self.output.getvalue())
self.assertEqual(set(state["machines"].keys()),
set([unicode(i) for i in [0, 1, 2, 3, 4, 5, 6]]))
services = state["services"]
self.assertEqual(set(services["memcache"].keys()),
set(["charm", "relations", "units"]))
self.assertEqual(set(services["mysql"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["varnish"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["wordpress"].keys()),
set(["charm", "relations", "units"]))
for service in services.itervalues():
self.assertTrue(service["charm"].startswith("local:series/"))
self.assertEqual(state["machines"][u"0"],
{"instance-id": 0,
"instance-state": "unknown",
"dns-name": "steamcloud-1.com",
"state": "down"})
self.assertEqual(services["mysql"]["relations"],
{"db": "wordpress"})
self.assertEqual(services["mysql"]["units"]["mysql/1"]["open-ports"],
[])
self.assertEqual(services["wordpress"]["relations"],
{"cache": "memcache",
"db": "mysql",
"proxy": "varnish"})
self.assertEqual(
services["varnish"],
{
"exposed": True,
"units":
{"varnish/1": {
"machine": 4,
"public-address": "varnish-1.example.com",
"open-ports": ["80/tcp"],
"state": "started",
"relations": {"proxy": {"state": "up"}}},
"varnish/0": {
"machine": 3,
"public-address": "varnish-0.example.com",
"open-ports": ["80/tcp"],
"state": "started",
"relations": {"proxy": {"state": "up"}}}},
"charm": "local:series/varnish-1",
"relations": {"proxy": "wordpress"}})
def test_render_json(self):
yield self.build_topology()
self.mock_environment()
self.mocker.replay()
yield status.status(self.environment, [], status.render_json,
self.output, None)
state = json.loads(self.output.getvalue())
self.assertEqual(set(state["machines"].keys()),
set([unicode(i) for i in [0, 1, 2, 3, 4, 5, 6]]))
services = state["services"]
self.assertEqual(set(services["memcache"].keys()),
set(["charm", "relations", "units"]))
self.assertEqual(set(services["mysql"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["varnish"].keys()),
set(["exposed", "charm", "relations", "units"]))
self.assertEqual(set(services["wordpress"].keys()),
set(["charm", "relations", "units"]))
for service in services.itervalues():
self.assertTrue(service["charm"].startswith("local:series/"))
self.assertEqual(
state["machines"][u"0"], {
"instance-id": 0,
"instance-state": "unknown",
"dns-name": "steamcloud-1.com",
"state": "down"
})
self.assertEqual(services["mysql"]["relations"], {"db": "wordpress"})
self.assertEqual(services["mysql"]["units"]["mysql/1"]["open-ports"],
[])
self.assertEqual(services["wordpress"]["relations"], {
"cache": "memcache",
"db": "mysql",
"proxy": "varnish"
})
self.assertEqual(
services["varnish"], {
"exposed": True,
"units": {
"varnish/1": {
"machine": 4,
"public-address": "varnish-1.example.com",
"open-ports": ["80/tcp"],
"state": "started",
"relations": {
"proxy": {
"state": "up"
}
}
},
"varnish/0": {
"machine": 3,
"public-address": "varnish-0.example.com",
"open-ports": ["80/tcp"],
"state": "started",
"relations": {
"proxy": {
"state": "up"
}
}
}
},
"charm": "local:series/varnish-1",
"relations": {
"proxy": "wordpress"
}
})
