Change one_of to OneOf

malcolm/core/enummeta.py

@@ -4,20 +4,20 @@
 class EnumMeta(AttributeMeta):
     """Meta object containing information for a enum"""
 
-    def __init__(self, name, description, one_of):
+    def __init__(self, name, description, oneOf):
         super(EnumMeta, self).__init__(name=name, description=description)
 
-        self.one_of = one_of
+        self.oneOf = oneOf
 
-    def set_one_of(self, one_of):
+    def set_one_of(self, oneOf):
         """
         Set allowed values
 
         Args:
-            one_of(list): List of allowed values
+            oneOf(list): List of allowed values
         """
 
-        self.one_of = one_of
+        self.oneOf = oneOf
 
     def validate(self, value):
         """
@@ -32,7 +32,7 @@ def validate(self, value):
             ValueError: If value not valid
         """
 
-        if value in self.one_of:
+        if value in self.oneOf:
             return value
         else:
             raise ValueError("%s is not a valid value" % value)
@@ -41,7 +41,7 @@ def to_dict(self):
         """Convert object attributes into a dictionary"""
 
         d = super(EnumMeta, self).to_dict()
-        d['one_of'] = self.one_of
+        d['oneOf'] = self.oneOf
 
         return d
 
@@ -56,8 +56,8 @@ def from_dict(cls, name, d):
         """
 
         description = d['description']
-        one_of = d['one_of']
-        enum_meta = EnumMeta(name, description, one_of)
+        oneOf = d['oneOf']
+        enum_meta = EnumMeta(name, description, oneOf)
 
         return enum_meta
 

tests/test_core/test_enummeta.py

@@ -11,52 +11,57 @@
 class TestInit(unittest.TestCase):
 
     def setUp(self):
-        self.boolean_meta = EnumMeta("TestMeta", "test description", [1, 2, 3])
+        self.enum_meta = EnumMeta("TestMeta", "test description", [1, 2, 3])
 
     def test_values_after_init(self):
-        self.assertEqual("TestMeta", self.boolean_meta.name)
+        self.assertEqual("TestMeta", self.enum_meta.name)
         self.assertEqual("test description",
-                         self.boolean_meta.description)
+                         self.enum_meta.description)
         self.assertEqual(EnumMeta.metaOf, "malcolm:core/Enum:1.0")
 
 
 class TestValidate(unittest.TestCase):
 
     def setUp(self):
-        self.boolean_meta = EnumMeta("TestMeta", "test description", [1, 2, 3])
+        self.enum_meta = EnumMeta("TestMeta", "test description", [1, 2, 3])
 
     def test_given_valid_value_then_return(self):
-        response = self.boolean_meta.validate(1)
+        response = self.enum_meta.validate(1)
         self.assertEqual(1, response)
 
     def test_given_invalid_value_then_raises(self):
         with self.assertRaises(ValueError):
-            self.boolean_meta.validate(0)
+            self.enum_meta.validate(0)
+
+    def test_set_one_of(self):
+        self.enum_meta.set_one_of([4, 5, 6])
+
+        self.assertEqual([4, 5, 6], self.enum_meta.oneOf)
 
 
 class TestSerialisation(unittest.TestCase):
 
     def setUp(self):
-        self.string_meta = EnumMeta("Test", "test description", [1, 2, 3])
+        self.enum_meta = EnumMeta("Test", "test description", [1, 2, 3])
 
     def test_to_dict(self):
         expected_dict = OrderedDict()
         expected_dict["description"] = "test description"
         expected_dict["metaOf"] = "malcolm:core/Enum:1.0"
-        expected_dict["one_of"] = [1, 2, 3]
+        expected_dict["oneOf"] = [1, 2, 3]
 
-        response = self.string_meta.to_dict()
+        response = self.enum_meta.to_dict()
 
         self.assertEqual(expected_dict, response)
 
     def test_from_dict(self):
         d = dict(description="test description",
                  metaOf="malcolm:core/Enum:1.0",
-                 one_of=[1, 2, 3])
+                 oneOf=[1, 2, 3])
         s = AttributeMeta.from_dict("me", d)
         self.assertEqual(type(s), EnumMeta)
         self.assertEqual(s.name, "me")
-        self.assertEqual(s.one_of, [1, 2, 3])
+        self.assertEqual(s.oneOf, [1, 2, 3])
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)