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