def test_delete_attribute_values_with_superclass(self):
        scl = CClass(self.mcl, "SCL", attributes={
            "intVal": 20, "intVal2": 30})
        cl = CClass(self.mcl, "C", superclasses=scl, attributes={
            "isBoolean": True,
            "intVal": 1})
        o = CObject(cl, "o", values={
            "isBoolean": False})
        o.delete_value("isBoolean")
        o.delete_value("intVal2")
        eq_(o.values, {"intVal": 1})

        o.set_value("intVal", 2, scl)
        o.set_value("intVal", 3, cl)
        eq_(o.values, {"intVal": 3})
        o.delete_value("intVal")
        eq_(o.values, {"intVal": 2})

        o.set_value("intVal", 2, scl)
        o.set_value("intVal", 3, cl)
        o.delete_value("intVal", cl)
        eq_(o.values, {"intVal": 2})

        o.set_value("intVal", 2, scl)
        o.set_value("intVal", 3, cl)
        o.delete_value("intVal", scl)
        eq_(o.values, {"intVal": 3})
 def test_delete_attribute_values(self):
     cl = CClass(self.mcl, "C", attributes={
         "isBoolean": True,
         "intVal": 1,
         "floatVal": 1.1,
         "string": "abc",
         "list": ["a", "b"]})
     o = CObject(cl, "o")
     o.delete_value("isBoolean")
     o.delete_value("intVal")
     list_value = o.delete_value("list")
     eq_(o.values, {'floatVal': 1.1, 'string': 'abc'})
     eq_(list_value, ['a', 'b'])
    def test_attribute_values_exceptional_cases(self):
        cl = CClass(self.mcl, "C", attributes={"b": True})
        o1 = CObject(cl, "o")
        o1.delete()

        try:
            o1.get_value("b")
            exception_expected_()
        except CException as e:
            eq_(e.value, "can't get value 'b' on deleted object")

        try:
            o1.set_value("b", 1)
            exception_expected_()
        except CException as e:
            eq_(e.value, "can't set value 'b' on deleted object")

        try:
            o1.delete_value("b")
            exception_expected_()
        except CException as e:
            eq_(e.value, "can't delete value 'b' on deleted object")

        try:
            o1.values = {"b": 1}
            exception_expected_()
        except CException as e:
            eq_(e.value, "can't set values on deleted object")

        try:
            # we just use list here, in order to not get a warning that o1.values has no effect
            list(o1.values)
            exception_expected_()
        except CException as e:
            eq_(e.value, "can't get values on deleted object")

        o = CObject(cl, "o")
        try:
            o.delete_value("x")
            exception_expected_()
        except CException as e:
            eq_(e.value, "attribute 'x' unknown for 'o'")
Exemple #4
0
    def test_links_as_attribute_values(self):
        code = CClass(self.mcl, "Code")
        source = CClass(self.mcl, "Source")
        code.association(source, "[contained_code] * -> [source] *")
        code_a = CClass(self.mcl, "Code A", superclasses=code)
        code_b = CClass(self.mcl, "Code B", superclasses=code)
        a_b_association = code_a.association(code_b,
                                             "a_b: [code_a] * -> [code_b] *",
                                             superclasses=code)
        code_a1 = CObject(code_a, "code_a1")
        code_b1 = CObject(code_b, "code_b1")
        code_b2 = CObject(code_b, "code_b2")
        a_b_links = add_links({code_a1: [code_b1, code_b2]},
                              association=a_b_association)

        links_list = [code_a1, code_b2, code_b1, a_b_links[0], a_b_links[1]]

        collection_type = CClass(self.mcl,
                                 "Collection Type",
                                 attributes={
                                     "primary_code": code,
                                     "default_value_code": a_b_links[0],
                                     "codes": list,
                                     "default_values_list": links_list
                                 })
        collection = CObject(collection_type)

        eq_(collection.get_value("primary_code"), None)
        eq_(collection.get_value("default_value_code"), a_b_links[0])
        eq_(collection.get_value("codes"), None)
        eq_(collection.get_value("default_values_list"), links_list)

        collection.set_value("primary_code", a_b_links[1])
        collection.set_value("default_value_code", a_b_links[1])
        collection.set_value("codes", [code_a1, a_b_links[0]])
        collection.set_value("default_values_list",
                             [a_b_links[0], a_b_links[1]])

        eq_(collection.get_value("primary_code"), a_b_links[1])
        eq_(collection.get_value("default_value_code"), a_b_links[1])
        eq_(collection.get_value("codes"), [code_a1, a_b_links[0]])
        eq_(collection.get_value("default_values_list"),
            [a_b_links[0], a_b_links[1]])

        collection.values = {
            'default_values_list': [a_b_links[0]],
            "codes": []
        }

        eq_(
            collection.values, {
                'default_value_code': a_b_links[1],
                'default_values_list': [a_b_links[0]],
                'codes': [],
                'primary_code': a_b_links[1]
            })

        collection.delete_value("primary_code")
        collection.delete_value("default_value_code")
        collection.delete_value("codes")
        collection.delete_value("default_values_list")

        eq_(collection.get_value("primary_code"), None)
        eq_(collection.get_value("default_value_code"), None)
        eq_(collection.get_value("codes"), None)
        eq_(collection.get_value("default_values_list"), None)