def test_member_data_element(self): data_el = SimpleMemberDataElement.create() # Test nesteds. self.assert_equal(data_el.nesteds.keys(), []) parent_data_el = SimpleMemberDataElement.create() rc_nested_attr = MyEntityMember.get_attributes()['parent'] mp_nested_attr = MappedAttribute(rc_nested_attr) data_el.set_nested(mp_nested_attr, parent_data_el) self.assert_true(data_el.get_nested(mp_nested_attr) is parent_data_el) self.assert_equal(data_el.nesteds.keys(), ['parent']) # Test terminals. self.assert_equal(data_el.terminals.keys(), []) utc = timezone('UTC') ldt = datetime.datetime(2012, 8, 29, 16, 20, 0, tzinfo=utc) term_attr_data = OrderedDict(text='foo', number=0, date_time=ldt) for term_attr_name, term_attr_value in term_attr_data.items(): rc_attr = MyEntityMember.get_attributes()[term_attr_name] mp_attr = MappedAttribute(rc_attr) # Check setting to None value. data_el.set_terminal(mp_attr, None) self.assert_true(data_el.get_terminal(mp_attr) is None) data_el.set_terminal_converted(mp_attr, None) self.assert_true(data_el.get_terminal(mp_attr) is None) # Check setting to value. data_el.set_terminal(mp_attr, term_attr_value) self.assert_equal(data_el.get_terminal(mp_attr), term_attr_value) rpr_val = data_el.get_terminal_converted(mp_attr) data_el.set_terminal_converted(mp_attr, rpr_val) self.assert_equal(data_el.get_terminal(mp_attr), term_attr_value) self.assert_equal(data_el.terminals.keys(), term_attr_data.keys()) # Printing. prt_str = str(data_el) self.assert_true(prt_str.startswith(data_el.__class__.__name__)) self.assert_true(prt_str.endswith(')'))
def test_types(self): attrs = MyEntityMember.get_attributes().values() self.assert_equal(attrs[0].name, ATTRIBUTE_NAMES[0]) self.assert_equal(attrs[0].kind, ResourceAttributeKinds.TERMINAL) self.assert_equal(attrs[0].entity_name, 'id') self.assert_equal(attrs[0].value_type, int) self.assert_equal(attrs[1].name, ATTRIBUTE_NAMES[1]) self.assert_equal(attrs[1].kind, ResourceAttributeKinds.MEMBER) self.assert_equal(attrs[1].entity_name, 'parent') self.assert_equal(attrs[1].value_type, IMyEntityParent) self.assert_equal(attrs[3].name, ATTRIBUTE_NAMES[3]) self.assert_equal(attrs[3].kind, ResourceAttributeKinds.COLLECTION) self.assert_equal(attrs[3].entity_name, 'children') self.assert_equal(attrs[3].value_type, IMyEntityChild) self.assert_equal(attrs[4].name, ATTRIBUTE_NAMES[4]) self.assert_equal(attrs[4].kind, ResourceAttributeKinds.TERMINAL) self.assert_equal(attrs[4].entity_name, 'text') self.assert_equal(attrs[4].value_type, str) self.assert_equal(attrs[6].name, ATTRIBUTE_NAMES[6]) self.assert_equal(attrs[6].kind, ResourceAttributeKinds.TERMINAL) self.assert_equal(attrs[6].entity_name, 'number') self.assert_equal(attrs[6].value_type, int) self.assert_true(MyEntityMember.is_member('parent')) self.assert_true(MyEntityMember.is_collection('children')) self.assert_true(MyEntityMember.is_resource('parent')) self.assert_true(MyEntityMember.is_resource('children')) self.assert_true( isinstance(getattr(MyEntityMember, 'id'), terminal_attribute))
def test_add_remove_same_member(self, resource_repo_with_data): coll = resource_repo_with_data.get_collection(IMyEntity) ent = MyEntity(id=1) mb = MyEntityMember.create_from_entity(ent) coll.add(mb) coll.remove(mb) assert len(coll) == 1
def test_new_stage_collection(self): ent = create_entity(entity_id=2, entity_text='too2') mb = MyEntityMember.create_from_entity(ent) nscoll = create_staging_collection(IMyEntity) self.assert_equal(len(nscoll), 0) nscoll.add(mb) self.assert_equal(len(nscoll), 1)
def _test(cnt_type, parent_repr_name, children_repr_name): entity = create_entity() mb = MyEntityMember.create_from_entity(entity) mp_reg = get_mapping_registry(cnt_type) mp = mp_reg.find_or_create_mapping(MyEntityMember) de = mp.map_to_data_element(mb) prx = DataElementAttributeProxy(de) self.assert_true(prx.get_data_element() is de) self.assert_equal(prx.id, 0) self.assert_equal(prx.text, 'TEXT') self.assert_equal(prx.number, 1) # The parent and children attributes are links. self.assert_true( isinstance(getattr(prx, parent_repr_name), LinkedDataElement)) children_el = getattr(prx, children_repr_name) if cnt_type is XmlMime: self.assert_is_none(children_el) else: self.assert_true(isinstance(children_el, LinkedDataElement)) # Nonexisting attribute raises error. self.assert_raises(AttributeError, getattr, prx, 'foo') self.assert_raises(AttributeError, setattr, prx, 'foo', 'murks') # Set terminal attribute. prx.id = 1 self.assert_equal(prx.id, 1) # Set nested attribute. setattr(prx, parent_repr_name, None) self.assert_is_none(getattr(prx, parent_repr_name)) self.assert_raises(ValueError, setattr, prx, parent_repr_name, 1)
def test_add(self): coll = get_root_collection(IMyEntity) ent = MyEntity(id=2) mb_add = MyEntityMember.create_from_entity(ent) coll.add(mb_add) transaction.commit() self.assert_equal(len(coll), 2)
def test_resource_to_url_floating_member(self): ent = create_entity(entity_id=2) mb = MyEntityMember.create_from_entity(ent) with self.assert_raises(ValueError) as cm: resource_to_url(mb) exc_msg = 'Can not generate URL for floating member' self.assert_true(cm.exception.message.startswith(exc_msg))
def test_add(self, resource_repo_with_data): coll = resource_repo_with_data.get_collection(IMyEntity) ent = MyEntity(id=2) mb_add = MyEntityMember.create_from_entity(ent) coll.add(mb_add) transaction.commit() assert len(coll) == 2
def test_resource_to_url_floating_member(self, member): ent = member.get_entity() mb = MyEntityMember.create_from_entity(ent) with pytest.raises(ValueError) as cm: resource_to_url(mb) exc_msg = 'Can not generate URL for floating resource' assert str(cm.value).startswith(exc_msg)
def test_update_nested_member_from_data(self): # Set up member that does not have a parent. ent = MyEntity(id=1) mb = MyEntityMember.create_from_entity(ent) # Set up second member with same ID that does have a parent. parent = MyEntityParent(id=0) upd_ent = MyEntity(id=1, parent=parent) upd_mb = MyEntityMember.create_from_entity(upd_ent) rpr = as_representer(mb, CsvMime) attribute_options = { ('parent', ): { WRITE_AS_LINK_OPTION: False }, } rpr.configure(attribute_options=attribute_options) de = rpr.data_from_resource(upd_mb) mb.update_from_data(de) self.assert_equal(mb.parent.id, parent.id)
def test_add_remove(self, resource_repo_with_data): coll = resource_repo_with_data.get_collection(IMyEntity) mb_rm = next(iter(coll)) coll.remove(mb_rm) ent = MyEntity(id=1) mb_add = MyEntityMember.create_from_entity(ent) coll.add(mb_add) transaction.commit() assert len(coll) == 1
def test_add_remove_same_member(self): coll = get_root_collection(IMyEntity) ent = MyEntity(id=1) mb = MyEntityMember.create_from_entity(ent) coll.add(mb) transaction.commit() coll.remove(mb) transaction.commit() self.assert_equal(len(coll), 1)
def test_add_remove(self): coll = get_root_collection(IMyEntity) mb_rm = iter(coll).next() coll.remove(mb_rm) ent = MyEntity(id=1) mb_add = MyEntityMember.create_from_entity(ent) coll.add(mb_add) transaction.commit() self.assert_equal(len(coll), 1)
def test_printing_with_none_value(self): data_el = SimpleMemberDataElement.create() self.assert_equal(data_el.terminals.keys(), []) rc_attr = MyEntityMember.get_attributes()['text'] mp_attr = MappedAttribute(rc_attr) data_el.set_terminal(mp_attr, None) # Need one None attr value. prt_str = str(data_el) self.assert_true(prt_str.startswith(data_el.__class__.__name__)) self.assert_true(prt_str.endswith(')'))
def test_repeated_add_remove_same_member_no_id(self): coll = get_root_collection(IMyEntity) ent1 = MyEntity() mb1 = MyEntityMember.create_from_entity(ent1) coll.add(mb1) transaction.commit() self.assert_equal(len(coll), 2) coll.remove(mb1) transaction.commit() self.assert_equal(len(coll), 1) ent2 = MyEntity() mb2 = MyEntityMember.create_from_entity(ent2) coll.add(mb2) transaction.commit() self.assert_equal(len(coll), 2) coll.remove(mb2) transaction.commit() self.assert_equal(len(coll), 1) self.assert_not_equal(mb1.id, mb2.id)
def test_clone(self): rc_attr = MyEntityMember.get_attributes()['number'] mp_attr = MappedAttribute(rc_attr) mp_attr_clone = mp_attr.clone() self.assert_equal(mp_attr.options, mp_attr_clone.options) self.assert_equal(mp_attr.name, mp_attr_clone.name) self.assert_equal(mp_attr.kind, mp_attr_clone.kind) self.assert_equal(mp_attr.value_type, mp_attr_clone.value_type) self.assert_equal(mp_attr.entity_name, mp_attr_clone.entity_name) self.assert_equal(mp_attr.cardinality, mp_attr_clone.cardinality)
def test_add_commit_remove_same_member(self, resource_repo_with_data): coll = resource_repo_with_data.get_collection(IMyEntity) ent1 = MyEntity() mb1 = MyEntityMember.create_from_entity(ent1) coll.add(mb1) transaction.commit() assert len(coll) == 2 # mb2 = coll[mb1.id] coll.remove(mb2) transaction.commit() assert len(coll) == 1
def test_basics(self): foo = MyEntity(id=0) foo_mb = MyEntityMember.create_from_entity(foo) self.coll.add(foo_mb) agg = self.coll.get_aggregate() self.assert_true(agg.get_by_id(foo.id) is foo) self.assert_true(agg.get_by_slug(foo.slug) is foo) foo1 = MyEntity(id=0) txt = 'FROBNIC' foo1.text = txt agg.update(foo1) self.assert_equal(agg.get_by_id(foo.id).text, txt) self.assert_equal(len(list(agg.iterator())), 1) agg.remove(foo) self.assert_equal(len(list(agg.iterator())), 0)
def test_sync_with_repository(self, resource_repo_with_data): coll = resource_repo_with_data.get_collection(IMyEntity) ent = MyEntity() mb_add = MyEntityMember.create_from_entity(ent) coll.add(mb_add) assert mb_add.id is None coll.get_aggregate().sync_with_repository() assert not mb_add.id is None rel_coll = mb_add.children ent_child = MyEntityChild() mb_add_child = MyEntityChildMember.create_from_entity(ent_child) rel_coll.add(mb_add_child) assert mb_add_child.id is None rel_coll.get_aggregate().sync_with_repository() assert not mb_add_child.id is None
def test_map_to_data_element_with_member(self): entity = create_entity() mb = MyEntityMember.create_from_entity(entity) mp_reg = get_mapping_registry(CsvMime) mp = mp_reg.find_or_create_mapping(MyEntityMember) mp1 = mp.clone(attribute_options={ ('parent', ): { WRITE_AS_LINK_OPTION: False }, }) de = mp1.map_to_data_element(mb) prx = DataElementAttributeProxy(de) self.assert_is_not_none(prx.parent) # entity.parent = None de1 = mp1.map_to_data_element(mb) prx1 = DataElementAttributeProxy(de1) self.assert_is_none(prx1.parent)
def test_map_to_data_element_with_collection(self): entity = create_entity() mb = MyEntityMember.create_from_entity(entity) mp_reg = get_mapping_registry(CsvMime) mp = mp_reg.find_or_create_mapping(MyEntityMember) mp1 = mp.clone( attribute_options={ ('children', ): { IGNORE_ON_WRITE_OPTION: False, WRITE_AS_LINK_OPTION: False }, ('children', 'children'): { IGNORE_ON_WRITE_OPTION: False, WRITE_AS_LINK_OPTION: False } }) de = mp1.map_to_data_element(mb) prx = DataElementAttributeProxy(de) self.assert_equal(len(prx.children), 1) self.assert_equal(len(prx.children[0].children), 1)
def test_names(self): self.assert_equal(MyEntityMember.get_attribute_names(), ATTRIBUTE_NAMES)
def test_nested_set(self): ent = MyEntity() mb = MyEntityMember.create_from_entity(ent) self.assert_true(mb.parent is None) self.assert_raises(AttributeError, setattr, mb, 'parent_text', 'foo')
def test_member_access(self): parent = MyEntityParent() entity = MyEntity(parent=parent) member = MyEntityMember.create_from_entity(entity) self.assert_true(isinstance(member.parent, MyEntityParentMember)) self.assert_true(member.parent.get_entity() is parent)
def test_terminal_access(self): entity = MyEntity() member = MyEntityMember.create_from_entity(entity) self.assert_true(isinstance(member.text, str)) self.assert_true(isinstance(member.number, int)) self.assert_true(isinstance(member.date_time, datetime.datetime))
def test_defaults(self): rc_attr = MyEntityMember.get_attributes()['number'] mp_attr = MappedAttribute(rc_attr) self.assert_equal(mp_attr.repr_name, rc_attr.name) self.assert_raises(AttributeError, getattr, mp_attr, 'foo') self.assert_true(str(mp_attr).startswith(mp_attr.__class__.__name__))
def test_ignore(self): rc_attr = MyEntityMember.get_attributes()['number'] mp_attr = MappedAttribute(rc_attr, options={IGNORE_OPTION: False}) self.assert_true(mp_attr.ignore_on_read is False) self.assert_true(mp_attr.ignore_on_write is False)