def setup(self):
template = get_data(self.config["template"])
files = {}
for key, filename in self.config.get("files", {}).items():
files[key] = get_data(filename)
parameters = self.config.get("parameters", rutils.LockedDict())
with parameters.unlocked():
if "network_id" not in parameters:
parameters["network_id"] = self._get_public_network_id()
for user, tenant_id in rutils.iterate_per_tenants(
self.context["users"]):
for name, path in self.config.get("context_parameters",
{}).items():
parameters[name] = self._get_context_parameter(user,
tenant_id,
path)
if "router_id" not in parameters:
networks = self.context["tenants"][tenant_id]["networks"]
parameters["router_id"] = networks[0]["router_id"]
if "key_name" not in parameters:
parameters["key_name"] = user["keypair"]["name"]
heat_scenario = heat_utils.HeatScenario(
{"user": user, "task": self.context["task"],
"owner_id": self.context["owner_id"]})
self.context["tenants"][tenant_id]["stack_dataplane"] = []
for i in range(self.config["stacks_per_tenant"]):
stack = heat_scenario._create_stack(template, files=files,
parameters=parameters)
tenant_data = self.context["tenants"][tenant_id]
tenant_data["stack_dataplane"].append([stack.id, template,
files, parameters])
def test___deepcopy__(self, mock_deepcopy):
mock_deepcopy.side_effect = lambda *args, **kw: (args, kw)
d = utils.LockedDict(foo="bar", spam={"a": ["b", {"c": "d"}]})
args, kw = d.__deepcopy__()
self.assertEqual({"memo": None}, kw)
self.assertEqual(({
"foo": "bar",
"spam": {
"a": ("b", {
"c": "d"
})
}
}, ), args)
self.assertEqual(dict, type(args[0]))
self.assertEqual(dict, type(args[0]["spam"]))
self.assertEqual(dict, type(args[0]["spam"]["a"][1]))
mock_deepcopy.reset_mock()
args, kw = d.__deepcopy__("foo_memo")
self.assertEqual(({
"foo": "bar",
"spam": {
"a": ("b", {
"c": "d"
})
}
}, ), args)
self.assertEqual({"memo": "foo_memo"}, kw)
def __init__(self, ctx):
super(BaseContext, self).__init__()
config = ctx.get("config", {})
if self.get_name() in config:
# TODO(boris-42): Fix tests, code is always using fullnames
config = config[self.get_name()]
else:
# TODO(boris-42): use [] instead of get() context full name is
# always presented.
config = config.get(self.get_fullname(), {})
# NOTE(amaretskiy): self.config is a constant data and must be
# immutable or write-protected type to prevent
# unexpected changes in runtime
if isinstance(config, dict):
if hasattr(self, "DEFAULT_CONFIG"):
for key, value in self.DEFAULT_CONFIG.items():
config.setdefault(key, value)
self.config = utils.LockedDict(config)
elif isinstance(config, list):
self.config = tuple(config)
else:
# NOTE(amaretskiy): It is improbable that config can be a None,
# number, boolean or even string,
# however we handle this
self.config = config
self.context = ctx
self.env = self.context.get("env", {})
def test_init_unlock_and_update(self):
def setitem(obj, key, value):
obj[key] = value
def delitem(obj, key):
del obj[key]
d = utils.LockedDict()
self.assertIsInstance(d, dict)
self.assertEqual({}, d)
d = utils.LockedDict(foo="bar", spam={"a": ["b", {"c": "d"}]})
self.assertEqual({"foo": "bar", "spam": {"a": ("b", {"c": "d"})}}, d)
self.assertIsInstance(d["spam"], utils.LockedDict)
self.assertIsInstance(d["spam"]["a"][1], utils.LockedDict)
self.assertRaises(RuntimeError, setitem, d, 123, 456)
self.assertRaises(RuntimeError, delitem, d, "foo")
self.assertRaises(RuntimeError, setitem, d["spam"]["a"][1], 123, 456)
self.assertRaises(RuntimeError, delitem, d["spam"]["a"][1], "c")
self.assertRaises(RuntimeError, d.update, {123: 456})
self.assertRaises(RuntimeError, d.setdefault, 123, 456)
self.assertRaises(RuntimeError, d.pop, "foo")
self.assertRaises(RuntimeError, d.popitem)
self.assertRaises(RuntimeError, d.clear)
self.assertEqual({"foo": "bar", "spam": {"a": ("b", {"c": "d"})}}, d)
with d.unlocked():
d["spam"] = 42
self.assertEqual({"foo": "bar", "spam": 42}, d)
d.clear()
self.assertEqual({}, d)
d.setdefault("foo", 42)
d.update({"bar": 24})
self.assertEqual({"foo": 42, "bar": 24}, d)
self.assertEqual(24, d.pop("bar"))
self.assertEqual(("foo", 42), d.popitem())
d[123] = 456
self.assertEqual({123: 456}, d)
self.assertRaises(RuntimeError, setitem, d, 123, 456)
self.assertRaises(RuntimeError, delitem, d, "foo")
def __init__(self, ctx):
config = ctx.get("config", {}).get(self.get_name(), {})
# NOTE(amaretskiy): self.config is a constant data and must be
# immutable or write-protected type to prevent
# unexpected changes in runtime
if isinstance(config, dict):
if hasattr(self, "DEFAULT_CONFIG"):
for key, value in self.DEFAULT_CONFIG.items():
config.setdefault(key, value)
self.config = utils.LockedDict(config)
elif isinstance(config, list):
self.config = tuple(config)
else:
# NOTE(amaretskiy): It is improbable that config can be a None,
# number, boolean or even string,
# however we handle this
self.config = config
self.context = ctx
