def test_parameter_failures(self):
from datetime import datetime, date, time
values = {
"datetime": ["2011-01-01"],
"time": ["12:32 "],
"date": ["2011-01-01-", datetime(2011, 1, 1, 12, 32, 11), "2011-01-01H12:32:11"],
"integer": ["112", date(2011, 1, 1)],
"float": [11, "11", None],
"boolean": ["Untrue", None],
"string": [999, None]}
for type, vals in values.iteritems():
for val in vals:
param_class = parameter_for_type(type)
self.assertRaises(TypeError, param_class, "test", val)
values = {
"datetime": ["2011-01-01"],
"time": ["12:32 "],
"date": ["2011-01-01-", datetime(2011, 1, 1, 12, 32, 11), "2011-01-01H12:32:11"],
"integer": ["112", date(2011, 1, 1)],
"float": [11, "11", None],
"boolean": ["Untrue", None],
"string": []
}
for type, vals in values.iteritems():
for val in vals:
param_class = parameter_for_type(type)
self.assertRaises(StringConversionError, param_class.from_string, "test")
def _saveParam(k, v):
try:
parameter_type = cls.declared_params[k]
except KeyError:
raise KeyError("%s has no parameter with key '%s'." % (cls.__original_class_name__, k))
# get the correct parameter class
parameter_class = parameter_for_type(parameter_type)
return parameter_class(name=k, value=v)
def __setitem__(self, key, val):
# TODO: Make more consistent
parameter_name = self.owning.declared_params[key]
parameter_class = parameter_for_type(parameter_name)
# TODO: Maybe put the None check inside the from_string methods
if val is None:
raise ValueError("Attempted to set None on a parameter.")
typed_val = parameter_class.from_string(val)
self.owning.params[key] = typed_val
def test_parameters(self):
from datetime import datetime, date, time
values = {
"datetime": [datetime(2011, 1, 1, 12, 32, 11)],
"time": [time(12, 32, 11)],
"date": [date(2011, 1, 1)],
"integer": [112, 20010213322],
"float": [11.2, 200.10213322],
"boolean": [True, False],
"string": [u"Kleiner Text", u"äöü", u"Юникод"]}
for type, vals in values.iteritems():
for val in vals:
param_class = parameter_for_type(type)
param_val = param_class("test", val)
self.assertEqual(val, param_class.from_string(param_val.value_string))
# testing str and repr as well
str(param_val)
repr(param_val)
def makeParam(key, value):
""" Takes a value list as input and concatenates with OR.
This means that {age: [1, 12, 13]} will yield a result if
age == 1 OR age == 12 OR age == 13.
"""
if not (isinstance(value, list) or isinstance(value, tuple)):
value = [value]
or_clause = []
# Ask for the type of the parameter according to the entity
parameter_class = parameter_for_type(entity.declared_params[key])
for val in value:
if callable(val):
# we’ve been given a function
or_clause.append(val(parameter_class.value))
elif parameter_class == StringParameter:
# test string using ‘like’
if not options["strict"]:
val = "%" + val + "%"
or_clause.append(parameter_class.value.like(val))
else:
if options["convert_string"]:
try:
val = parameter_class.from_string(val)
except StringConversionError:
if parameter_class == DateParameter:
# Here, we want to match a certain YEAR, a certain
# combination of YEAR-MONTH or a certain combination
# YEAR-MONTH-DAY from a date.
# Therefore, we need to extract YEAR, MONTH and DAY
# from a date and match those separately.
# Unfortunately, there is no common SQL function for
# this task, so we're left with ``date_part('year', date)``
# for Postgres and ``strftime('%Y', date)`` for Sqlite.
# We check the `engine_name` and generate the respective
# methods.
# get year month day
ymd = val.split('-')
clauses = []
from sqlalchemy.sql.expression import func
if self.connection.engine_name == "postgresql":
year_part = lambda value: func.date_part('year', value)
month_part = lambda value: func.date_part('month', value)
day_part = lambda value: func.date_part('day', value)
elif self.connection.engine_name == "sqlite":
year_part = lambda value: func.strftime('%Y', value)
month_part = lambda value: func.strftime('%m', value)
day_part = lambda value: func.strftime('%d', value)
else:
raise ValueError("Unsupported operation: Unknown engine name %r." %
self.connection.engine_name)
if len(ymd) > 0:
clauses.append(year_part(parameter_class.value) == ymd[0])
if len(ymd) > 1:
clauses.append(month_part(parameter_class.value) == ymd[1])
if len(ymd) > 2:
clauses.append(day_part(parameter_class.value) == ymd[2])
clause = (and_(*clauses))
or_clause.append(clause)
else:
raise
else:
or_clause.append(parameter_class.value == val)
# FIXME
return entity._params.of_type(parameter_class).any(or_(*or_clause))
