def testsweepconstructor(self):
"""
Here we test the sweep constructor. We do this by testing the type validation.
We also test the following keyword argument pairs:
- name, c_dict
- name, start, stop, step
- name, l_vals
- name, c_dict, ndx
"""
name = "sweep1"
xpath = "parameters/Run_Number"
c_dict = {"parameters/Run_Number": "5:10:1"}
start = 5
stop = 10
step = 1
l_vals = [3, 6, 7, 19]
change = Change.sweep(name, c_dict=c_dict, ndx=5)
self.assertEqual(change.change_list, ["sweep1"], msg="Failed to set change list with c_dict definition")
self.assertEqual(change.ndx, 5, msg="Failed to set index")
obj = change.jcd_objects[0]
self.assertEqual(obj.jcd["Changes"], [c_dict], msg="Failed to set sweep")
# ------ Test start/stop/step
del change
change = Change.sweep(name, xpath=xpath, start=start, stop=stop, step=step)
self.assertEqual(
change.change_list, ["sweep1"], msg="Failed to set change list with start/stop/step definition"
)
obj = change.jcd_objects[0]
self.assertEqual(obj.jcd["Changes"], [c_dict], msg="Failed to set sweep")
# -------- Test l_vals (Sweep with nonconsecutive values)
del change
change = Change.sweep(name, xpath=xpath, l_vals=l_vals)
self.assertEqual(
change.change_list, ["sweep1"], msg="Failed to set change list with start/stop/step definition"
)
self.assertEqual(
change.jcd_objects[0].jcd["Changes"], [{"parameters/Run_Number": "|".join(str(x) for x in l_vals)}]
)
def testsettype(self):
"""
We test the set_type method of the change class. We test setting each allowed type (which overrides the
previously saved type), and we test setting a type of a different type than string, and an invalid type
"""
change = Change()
# ------- Test each valid type
for type in Change.type_list:
change.type = type
self.assertEqual(change.type, type, msg="Failed to set type %s" % type)
# -------- Test invalid type
self.assertRaises(ValueError, setattr, change, "type", "super_type")
# -------- Test invalid object type
self.assertRaises(ValueError, setattr, change, "type", 5)
def testgetconstructor(self):
"""
We test the get_constructor method. We send in each of the valid types and get the constructors for
those types. We make sure each type gets its appropriate constructor
"""
func = Change.get_constructor("atomic")
self.assertEqual(func, Change.atomic, msg="Failed to get atomic constructor")
func = Change.get_constructor("node")
self.assertEqual(func, Change.node, msg="Failed to get node constructor")
func = Change.get_constructor("sweep")
self.assertEqual(func, Change.sweep, msg="Failed to get sweep constructor")
func = Change.get_constructor("arm")
self.assertEqual(func, Change.arm, msg="Failed to get arm constructor")
# -------- Try invalid option
self.assertRaises(ValueError, Change.get_constructor, "super_type")
def testnodeconstructor(self):
"""
Here we test the node constructor. We do this by checking against pass in types.
We also test passing in different types of modes (both valid and invalid), and without modes.
"""
# TODO: Test type validation
name = "change1"
node_list = [{"parameters/Run_Number": 5}]
change = Change.node(name, node_list)
self.assertEqual(change.change_list[0], "+change1", msg="Failed to add name to change list")
obj = change.jcd_objects[0]
self.assertEqual(obj.name, "change1", msg="Failed to set JCD key")
self.assertEqual(obj.jcd["Changes"], node_list, msg="Failed to set node")
# --------- Test setting mode
del change
change = Change.node(name, node_list, mode="-", ndx=5)
self.assertEqual(change.change_list[0], "-change1", msg="Failed to add name to change list")
obj = change.jcd_objects[0]
self.assertEqual(obj.name, "change1", msg="Failed to set JCD key")
self.assertEqual(obj.jcd["Changes"], node_list, msg="Failed to set node")
self.assertEqual(change.ndx, 5, msg="Failed to set index")
# ------- Test invalid mode
del change
self.assertRaises(ValueError, Change.node, name=name, node=node_list, mode="p")
# ------ Test invalid mode type
self.assertRaises(ValueError, Change.node, name=name, node=node_list, mode=5)
def testaddnodechange(self):
"""
Here we test the add_node_change method of the Chnage class. We will do this
by trying a simple name, node pair, a name non-node pair (which should raise
a ValueError), a list of names and a single node (which should raise a ValueError),
a list of names and a list of nodes, a single name and a list of nodes.
"""
change = Change()
node1 = JCD({"Changes": [{"parameters/Run_Number": 5}]})
node2 = JCD({"Changes": [{"parameters/param2": 0.01}]})
# ------ Test invalid name type, valid node type
self.assertRaises(ValueError, change.add_node_change, 5, node1)
# ------ Test valid name type, invalid node type
self.assertRaises(ValueError, change.add_node_change, "change1", 5)
# ------ Test valid name and node
change.add_node_change("change1", node1)
self.assertEqual(len(change.change_list), 1, msg="More than one change added during single add node")
self.assertEqual(change.change_list[0], "change1", msg="Failed to add node change")
self.assertEqual(change.jcd_objects[0], node1, msg="Failed to add jcd object")
# ------- Test single name, list of nodes
del change
change = Change()
change.add_node_change("change1+change2", [node1, node2])
self.assertEqual(change.jcd_objects, [node1, node2], msg="Failed to set list of nodes with single name")
self.assertEqual(change.change_list[0], "change1+change2", msg="Failed to set single name with list of nodes")
# -------- Test list of names and list of nodes
del change
change = Change()
change.add_node_change(["change1", "change2"], [node1, node2])
self.assertEqual(
change.change_list[0], ["change1", "change2"], msg="Failed to set list of names with list of nodes"
)
self.assertEqual(change.jcd_objects, [node1, node2], msg="Failed to set list of nodes with list of names")
def testsetndx(self):
"""
We test setting the index of the change. Since the ndx can only be set once, we test to make sure the
ndx doesn't change when we set it again. We also try setting an invalid object type.
"""
change = Change()
# -------- Test invalid object type
self.assertRaises(ValueError, setattr, change, "ndx", "foo")
# --------- Test valid type and ndx
change.ndx = 5
self.assertEqual(change.ndx, 5, msg="Unable to set change index")
# -------- Test setting ndx again
change.ndx = 3000
self.assertEqual(change.ndx, 5, msg="Changed index after initial set")
# -------- Test deleter of ndx
del change.ndx
self.assertIs(change.ndx, None, msg="Deleter failed to delete ndx")
def testatomicconstructor(self):
"""
This tests the atomic constructor. We do this by testing the type checking.
"""
# TODO: Type checking
a_key = "parameters/Run_Number"
a_val = 5
a_dict = dict()
a_dict[a_key] = a_val
change = Change.atomic(dicts=a_dict, ndx=5)
self.assertEqual(change.change_list[0], a_dict, msg="Failed to set atomic change from dictionary")
self.assertEqual(change.ndx, 5, msg="Failed to set ndx from atomic constructor")
del change
change = Change.atomic(xpath=a_key, value=a_val)
self.assertEqual(change.change_list[0], a_dict, msg="Failed to set atomic change from xpath/value")
self.assertIs(change.ndx, None, msg="ndx set without argument")
def testarmconstructor(self):
"""
Here we test the arm constructor. We test the type validation first. After that, we test an arm with a
compound node and two simple nodes. This will test the entire functionality of the arm constructor.
"""
l_names = ["change1+change2", "+change1", "-change2"]
nodes = [[{"path/to/param1": 5}], [{"path/to/param2": 0.1}]]
change = Change.arm(l_names, nodes, ndx=5)
self.assertEqual(change.ndx, 5, msg="Failed to set ndx")
self.assertEqual(change.change_list[0], l_names, msg="Failed to set change list")
self.assertEqual(change.jcd_objects[0].jcd["Changes"], [{"path/to/param1": 5}], msg="Failed to set change1")
self.assertEqual(change.jcd_objects[0].name, "change1", msg="Failed to set JCD change name")
self.assertEqual(change.jcd_objects[1].jcd["Changes"], [{"path/to/param2": 0.1}], msg="Failed to set change2")
self.assertEqual(change.jcd_objects[1].name, "change2", msg="Failed to set JCD change name")
def testaddatomicchange(self):
"""
Here we test the add_atomic_change method. We attempt to add a change with an index, without and index,
with a valid change type and with an invalid change type. We also set an ndx and try to set the ndx via
this method to make sure that the ndx is not overridden.
"""
change = Change()
# ---------- Test invalid change type (non-dictionary)
self.assertRaises(ValueError, change.add_atomic_change, "CHANGE")
# ---------- Test valid change type with ndx
valid_change = {"parameters/Run_Number": 5}
change.add_atomic_change(valid_change, ndx=5)
self.assertEqual(change.change_list[0], valid_change, msg="Failed to set atomic change")
# ---------- Test valid change with ndx after ndx already set
change2 = Change()
change2.ndx = 1
change2.add_atomic_change(valid_change, ndx=5)
self.assertEqual(change2.ndx, 1, msg="Set index after initial set")
self.assertEqual(change2.change_list[0], valid_change, msg="Failed to set atomic change")
