def test_double_deep_assignment(self): foo = PythonObject({ "bar": PythonObject({ "baz": PythonObject({ "bam": 10 }) }) }) Baz = UniversalObjectType({ "bam": IntegerType() }) Bar = UniversalObjectType({ "baz": Baz }) get_manager(foo).add_composite_type( UniversalObjectType({ "bar": Bar }) ) self.assertEquals(foo.bar.baz.bam, 10) foo.bar = PythonObject({ "baz": PythonObject({ "bam": 42 }) }, bind=Bar) self.assertEquals(foo.bar.baz.bam, 42)
def test_that_python_constraints_dont_spread_to_constrained_children(self): bar = PythonObject({ "baz": 42 }) foo = PythonObject({ "bar": bar }) # The first, stronger, type prevents the NO_SETTER_ERROR_COMPOSITE_TYPE spreading from foo to bar get_manager(bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() })) get_manager(foo).add_composite_type(NO_SETTER_ERROR_COMPOSITE_TYPE) self.assertIs(foo.bar, bar) self.assertEquals(len(get_manager(foo).attached_types), 1) self.assertEquals(len(get_manager(foo.bar).attached_types), 1) # ... but when bar is replaced with a new object without constraints, the PythonObjectType # spreads to the new object foo.bar = PythonObject({ "baz": 123 }) self.assertIsNot(foo.bar, bar) self.assertEquals(len(get_manager(foo.bar).attached_types), 1) # Now that the new object has the PythonObjectType constraint, we can't bind a stronger # constraint with self.assertRaises(CompositeTypeIncompatibleWithTarget): get_manager(foo.bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() }))
def test_modifying(self): At = UniversalObjectType({ "foo": IntegerType() }) Bt = UniversalObjectType({ "bar": At }) A = PythonObject({ "foo": 5 }) B = PythonObject({ "bar": A }, bind=Bt) self.assertEquals(len(get_manager(A).attached_types), 1) self.assertEquals(get_manager(A).attached_type_counts[id(At)], 1) B.bar = PythonObject({ "foo": 42 }, bind=At) self.assertEquals(len(get_manager(A).attached_types), 0) self.assertEquals(get_manager(A).attached_type_counts[id(At)], 0)
def test_changes_blocked_without_micro_ops(self): foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) get_manager(foo) with self.assertRaises(Exception): foo.bar = "hello"
def test_python_replacing_object_works(self): foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) get_manager(foo).add_composite_type(DEFAULT_COMPOSITE_TYPE) foo.bar = PythonObject({ "baz": 123 }) self.assertEquals(foo.bar.baz, 123)
def test_python_like_type(self): foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) get_manager(foo).add_composite_type(RICH_TYPE) foo.bar.baz = 22 foo.bar = "hello" self.assertEquals(foo.bar, "hello")
def test_very_broad_assignment(self): foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) get_manager(foo).add_composite_type( UniversalObjectType({ "bar": AnyType() }) ) foo.bar = "hello" self.assertEquals(foo.bar, "hello")
def test_java_like_object(self): obj = PythonObject({ "foo": "hello" }) get_manager(obj).add_composite_type(CompositeType({ ("get", "foo"): GetterMicroOpType("foo", StringType()), ("set", "foo"): SetterMicroOpType("foo", StringType()) }, name="test")) self.assertEquals(obj.foo, "hello") obj.foo = "what" self.assertEquals(obj.foo, "what") with self.assertRaises(Exception): obj.bar = "hello"
def test_blocked_basic_assignment(self): foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) get_manager(foo).add_composite_type( UniversalObjectType({ "bar": UniversalObjectType({ "baz": IntegerType() }) }) ) with self.assertRaises(Exception): foo.bar = PythonObject({ "baz": "hello" })
def test_python_object_with_reference_can_be_replaced(self): bar = PythonObject({ "baz": 42 }) foo = PythonObject({ "bar": bar }) get_manager(bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() })) get_manager(foo).add_composite_type(DEFAULT_COMPOSITE_TYPE) foo.bar = PythonObject({ "baz": 123 }) self.assertEqual(foo.bar.baz, 123) foo.bar.baz = "what" self.assertEqual(foo.bar.baz, "what")
def test_basic_assignment(self): Bar = UniversalObjectType({ "baz": IntegerType() }) foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) get_manager(foo).add_composite_type( UniversalObjectType({ "bar": Bar }) ) foo.bar = PythonObject({ "baz": 42 }, bind=Bar) self.assertEquals(foo.bar.baz, 42)
def test_broad_assignment(self): foo = PythonObject({ "bar": PythonObject({ "baz": 42 }) }) Bar = UniversalObjectType({ "baz": AnyType() }) get_manager(foo).add_composite_type( UniversalObjectType({ "bar": Bar }) ) foo.bar = PythonObject({ "baz": "hello" }, bind=Bar) self.assertEquals(foo.bar.baz, "hello")