def _get_property_from_mapper(self, resource, attr, args):
"""
Matches calls like (resource, attr_name). Fetches the property from
the mapper and does a recursive call passing it as ``attr`` so other
rules can match the property by type.
"""
prop = get_mapper(resource).get_property(attr)
return self.get(resource, prop, args)
def test_relation(self):
user = get_mapper(model.Address).get_property('user')
field = self.factory(model.Address, user)
self.failUnless(isinstance(field, fields.Relation), ` field `)
self.failUnless(field.required, ` field `)
foreign_keys = get_foreign_keys(user)
foreign_keys = [c.name for c in foreign_keys]
self.failUnlessEqual(foreign_keys, ['user_id'])
def test_foreign_key(self):
user_id = get_mapper(model.Address).get_property('user_id').columns[0]
field = self.factory(model.Address, user_id)
self.failUnless(isinstance(field, fields.ForeignKey), ` field `)
self.failUnless(field.required, ` field `)
field = field.type
self.failUnless(isinstance(field, fields.Integer), ` field `)
self.failUnless(field.required, ` field `)
def test_primary_key(self):
id = get_mapper(model.Address).get_property('id').columns[0]
field = self.factory(model.Address, id)
self.failUnless(isinstance(field, fields.PrimaryKey), ` field `)
self.failUnless(field.auto, ` field `)
self.failUnless(not field.required, ` field `)
field = field.type
self.failUnless(isinstance(field, fields.Integer), ` field `)
self.failUnless(field.required, ` field `)
def _reflect_models(self):
# Use the scoped_session sqlsoup creates. This is suboptimal, we
# need a way to bring the objects sqlsoup creates into our
# session (which we can control: set to transactional, etc...)
# If we don't use soup's session SA barfs with a
# 'object is already attached to session blah'
metadata = MetaData(self.engine)
metadata.reflect()
# workaround: sqlalchemy does unicode names reflecting and SqlSoup
# doesn't like it
for name, table in metadata.tables.iteritems():
table.name = str(name)
metadata.tables[table.name] = metadata.tables.pop(name)
if self.reflect == 'all':
table_names = metadata.tables.keys()
else:
table_names = self.reflect
db = sqlsoup.SqlSoup(metadata, self.session_factory)
entities = dict()
for table_name in table_names:
try:
entities[table_name] = db.entity(table_name)
except sqlsoup.PKNotFoundError:
log.warn("reflection: skipping table " + table_name + "...")
mappers = dict((e, get_mapper(e)) for e in entities.itervalues())
# autogenerate relations
for table_name, entity in entities.iteritems():
self._fix_soup_entity(entity)
for prop in mappers[entity].iterate_properties:
if isinstance(prop, ColumnProperty):
for col in prop.columns:
# See if the column is a foreign key
try:
fk = get_foreign_keys(col)[0]
except IndexError:
# It isn't...
continue
# It is, lookup parent mapper
relation_kwds = dict()
for parent, m in mappers.iteritems():
if fk.references(m.local_table):
if col.primary_key:
relation_kwds[
"cascade"] = 'all, delete-orphan'
break
# Relate it
assert getattr(db, table_name) is entity
#
parent.relate(
self.names_for_resource(entity)[1],
entity,
backref=self.names_for_resource(parent)[0],
**relation_kwds)
return entities.values()
def test_sequence(self):
id = get_mapper(model.User).get_property('id')
field = self.factory(model.User, id)
self.failUnless(isinstance(field, fields.PrimaryKey), ` field `)
self.failUnless(not field.required, ` field `)
self.failUnless(field.auto, ` field `)
self.failUnless(not field.has_default, ` field `)
field = field.type
self.failUnless(isinstance(field, fields.Integer), ` field `)
self.failUnless(field.required, ` field `)
def get_id(self, obj):
m = get_mapper(obj)
if not m:
raise TypeError("WTF are you sending to me! %r" % (obj, ))
def _replace_slash(s):
if isinstance(s, basestring):
return s.replace('/', self.slash_replacement)
return s
pk = map(_replace_slash, m.primary_key_from_instance(obj))
return self.composite_id_separator.join(map(unicode, pk))
def _fields_for_mapped_class(self, resource, attr, args):
"""
Matches calls like (resource,None) which means that we're operating
on a resource, not on it's properties/attributes.
Begin a recursive descent passing (resource, attr_name) for each
attribute.
"""
#XXX: It should be documented somewhere that FieldFactories
# should pass the attr. names as a string sometime during
# the recursive descent so rules that match (resource, attr_name)
# can kick in
# -> This applies also to other factories like viewfactories
properties = get_mapper(resource).iterate_properties
args['fields'] = filter(
lambda f: f is not None and not f.name.startswith('_'),
[self(resource, prop.key) for prop in properties])
return fields.FieldList
def get_column(self, resource, column_name, query):
resource_pure=resource
columns=column_name.split(".")
stack= ()
for i in xrange(len(columns)-1):
parent_pure=resource_pure
parent=resource
attr=columns[i]
stack=stack + ((parent, attr),)
prop = get_mapper(parent_pure).get_property(attr)
if isinstance(prop, RelationshipProperty):
resource_pure = get_other(prop)
if stack in self.joins:
resource = self.joins[stack]
else:
resource = aliased(resource_pure)
self.joins[stack] = resource
else:
resource_pure = resource = getattr(parent, attr)
col=columns[-1]
is_date = hasattr(resource, 'property')\
and isinstance(resource.property, ColumnProperty)\
and not isinstance(resource.property, RelationshipProperty)\
and hasattr(resource.property, 'columns')\
and (
isinstance(resource.property.columns[0].type, types.Date)
or
isinstance(resource.property.columns[0].type, types.DateTime))
if not is_date:
return getattr(resource, col)
else:
return date_part(col, resource)
def test_mapper_renamed_key(self):
prop = get_mapper(model.CountryModified).get_property('label')
field = self.factory(model.CountryModified, prop)
self.failUnless(field.name == 'label', ` field `)
def setUp(self):
self.factory = SAFieldFactory()
#XXX: The following line, for some reason, prevents the first test
# from failing if coverage is on, go figure
get_mapper(model.User)
def test_unicode_field(self):
prop = get_mapper(model.User).get_property('name')
field = self.factory(model.User, prop)
self.failUnless(isinstance(field, fields.Unicode), ` field `)
def test_related_list(self):
prop = get_mapper(model.User).get_property('addresses')
field = self.factory(model.User, prop)
self.failUnless(isinstance(field, fields.List), ` field `)
self.failUnless(not field.required, ` field `)
def test_explicit_from_info(self):
prop = get_mapper(model.PowerUser).get_property('description')
field = self.factory(model.PowerUser, prop)
self.failUnless(isinstance(field, fields.HTMLText), ` field `)
def test_length(self):
prop = get_mapper(model.User).get_property('name')
field = self.factory(model.User, prop)
self.failUnlessEqual(field.length, 15)
def test_non_auto_pk(self):
code = get_mapper(model.Country).get_property('code')
field = self.factory(model.Country, code)
self.failUnless(isinstance(field, fields.PrimaryKey), ` field `)
self.failUnless(field.required, ` field `)
self.failUnless(not field.auto, ` field `)
