def test_task_line_group_lines(tva, unity):
from autonomie.models.task.task import TaskLineGroup
schema = SQLAlchemySchemaNode(TaskLineGroup, includes=('lines', ))
schema = schema.bind()
value = {'lines': []}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {
'lines': [{
'cost': 15,
'tva': 20,
'description': u'description',
'unity': u"Mètre",
"quantity": 5,
}]
}
assert schema.deserialize(value) == {
'lines': [{
'cost': 1500000,
'tva': 2000,
'description': u'description',
'unity': u"Mètre",
"quantity": 5.0,
'order': 1
}]
}
def test_task_line(config, request_with_config, estimation, unity, tva,
product, product_without_tva):
from autonomie.models.task.task import TaskLine
schema = SQLAlchemySchemaNode(TaskLine)
request_with_config.context = estimation
schema = schema.bind(request=request_with_config)
value = {
'description': u'test',
'cost': 450,
'quantity': 1,
'unity': u'Mètre',
'tva': 20.00,
'product_id': product.id
}
assert schema.deserialize(value) == {
'description': u'test',
'cost': 45000000,
'quantity': 1.0,
'unity': u'Mètre',
'tva': 2000,
'product_id': product.id,
'order': 1
}
value = {
'description': u'test',
'cost': 450,
'quantity': 1,
'unity': u'Mètre',
'tva': 20.00,
'product_id': product_without_tva.id
}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_estimation_payment_lines():
from autonomie.models.task.estimation import Estimation
schema = SQLAlchemySchemaNode(Estimation, includes=('payment_lines', ))
schema = schema.bind()
value = {'payment_lines': []}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {
'payment_lines': [{
'task_id': 5,
'date': datetime.date.today().isoformat(),
'amount': 12.5,
'description': u"Description"
}]
}
expected_value = {
'payment_lines': [{
'task_id': 5,
'date': datetime.date.today(),
'amount': 1250000,
'description': u"Description",
'order': 1
}]
}
assert schema.deserialize(value) == expected_value
def test_discount_line_description():
from autonomie.models.task.task import DiscountLine
schema = SQLAlchemySchemaNode(DiscountLine, includes=('description', ))
value = {'description': u"description"}
assert schema.deserialize(value) == value
value = {"description": u"<br /><p></p>\n"}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_group_task_id():
from autonomie.models.task.task import TaskLineGroup
schema = SQLAlchemySchemaNode(TaskLineGroup, includes=('task_id', ))
value = {'task_id': 5}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_payment_line_task_id():
from autonomie.models.task.estimation import PaymentLine
schema = SQLAlchemySchemaNode(PaymentLine, includes=('task_id', ))
value = {'task_id': 5}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_quantity():
from autonomie.models.task.task import TaskLine
schema = SQLAlchemySchemaNode(TaskLine, includes=('quantity', ))
schema = schema.bind()
value = {'quantity': 1}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_payment_date():
from autonomie.models.task.invoice import Payment
schema = SQLAlchemySchemaNode(Payment, includes=('date', ))
schema = schema.bind()
value = {'date': NOW.isoformat()}
assert schema.deserialize(value) == {'date': NOW}
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_payment_line_date():
import datetime
from autonomie.models.task.estimation import PaymentLine
schema = SQLAlchemySchemaNode(PaymentLine, includes=('date', ))
schema = schema.bind()
value = {'date': datetime.date.today().isoformat()}
assert schema.deserialize(value) == {'date': datetime.date.today()}
value = {}
assert schema.deserialize(value) == value
def test_payment_line_description():
from autonomie.models.task.estimation import PaymentLine
schema = SQLAlchemySchemaNode(PaymentLine, includes=('description', ))
schema = schema.bind()
value = {'description': "test\n"}
assert schema.deserialize(value) == value
value = {'description': "\n"}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_mentions(mention):
from autonomie.models.task.task import Task
schema = SQLAlchemySchemaNode(Task, includes=('mentions', ))
schema = schema.bind()
value = {'mentions': [mention.id]}
assert schema.deserialize(value) == value
value = {'mentions': [mention.id + 1]}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_discount_line_task_id():
from autonomie.models.task.task import DiscountLine
schema = SQLAlchemySchemaNode(DiscountLine, includes=('task_id', ))
schema = schema.bind()
value = {'task_id': 5}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_date():
import datetime
from autonomie.models.task.task import Task
schema = SQLAlchemySchemaNode(Task, includes=('date', ))
schema = schema.bind()
value = {'date': datetime.date.today().isoformat()}
assert schema.deserialize(value) == {'date': datetime.date.today()}
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_estimation_signed_status():
from autonomie.models.task.estimation import Estimation
schema = SQLAlchemySchemaNode(Estimation, includes=('signed_status', ))
schema = schema.bind()
value = {'signed_status': u"signed"}
assert schema.deserialize(value) == value
value = {'signed_status': u"error"}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_payment_bank_id(bank):
from autonomie.models.task.invoice import Payment
schema = SQLAlchemySchemaNode(Payment, includes=('bank_id', ))
schema = schema.bind()
value = {'bank_id': bank.id}
assert schema.deserialize(value) == value
value = {'bank_id': bank.id + 1}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_unity(unity):
from autonomie.models.task.task import TaskLine
schema = SQLAlchemySchemaNode(TaskLine, includes=('unity', ))
schema = schema.bind()
value = {'unity': u"Mètre"}
assert schema.deserialize(value) == value
value = {'unity': u"Panies"}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
schema.deserialize(value)
def test_task_payment_conditions():
from autonomie.models.task.estimation import Task
schema = SQLAlchemySchemaNode(Task, includes=('payment_conditions', ))
schema = schema.bind()
value = {'payment_conditions': u"À réception de facture"}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_cancelinvoice_invoice_id():
from autonomie.models.task.invoice import CancelInvoice
schema = SQLAlchemySchemaNode(CancelInvoice, includes=('invoice_id', ))
schema = schema.bind()
value = {'invoice_id': 5}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_cost():
from autonomie.models.task.task import TaskLine
schema = SQLAlchemySchemaNode(TaskLine, includes=('cost', ))
schema = schema.bind()
value = {'cost': 12.50}
assert schema.deserialize(value) == {'cost': 1250000}
value = {'cost': 'a'}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_discount_line_amount():
from autonomie.models.task.task import DiscountLine
schema = SQLAlchemySchemaNode(DiscountLine, includes=('amount', ))
schema = schema.bind()
value = {'amount': 12.50}
assert schema.deserialize(value) == {'amount': 1250000}
value = {'amount': 'a'}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_tva(tva):
from autonomie.models.task.task import TaskLine
schema = SQLAlchemySchemaNode(TaskLine, includes=('tva', ))
schema = schema.bind()
value = {'tva': 20.00}
assert schema.deserialize(value) == {'tva': 2000}
value = {'tva': 21.00}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_address():
from autonomie.models.task.task import Task
schema = SQLAlchemySchemaNode(Task, includes=('address', ))
schema = schema.bind()
value = {'address': u"address"}
assert schema.deserialize(value) == value
value = {"address": u"<br /><p></p>\n"}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_product_id(config, request_with_config, estimation,
product):
from autonomie.models.task.task import TaskLine
schema = SQLAlchemySchemaNode(TaskLine, includes=('product_id', ))
request_with_config.context = estimation
schema = schema.bind(request=request_with_config)
value = {'product_id': product.id}
assert schema.deserialize(value) == value
value = {'product_id': product.id + 1}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
assert schema.deserialize(value) == value
def test_payment_remittance_amount():
from autonomie.models.task.invoice import Payment
schema = SQLAlchemySchemaNode(Payment, includes=('remittance_amount', ))
schema = schema.bind()
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {'remittance_amount': "test"}
assert schema.deserialize(value) == value
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_estimation_paymentDisplay():
from autonomie.models.task.estimation import Estimation
schema = SQLAlchemySchemaNode(Estimation, includes=('paymentDisplay', ))
schema = schema.bind()
value = {'paymentDisplay': u'SUMMARY'}
assert schema.deserialize(value) == value
value = {}
assert schema.deserialize(value) == {'paymentDisplay': u'NONE'}
value = {'paymentDisplay': u'ERROR'}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_payment_mode(mode):
from autonomie.models.task.invoice import Payment
schema = SQLAlchemySchemaNode(Payment, includes=('mode', ))
schema = schema.bind()
value = {'mode': mode.label}
assert schema.deserialize(value) == value
value = {'mode': "error"}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_task_line_groups(tva, unity):
from autonomie.models.task.task import Task
schema = SQLAlchemySchemaNode(Task, includes=('line_groups', ))
schema = schema.bind()
value = {'line_groups': []}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {
'line_groups': [{
'task_id':
5,
'title':
u"title",
'description':
u"description",
"order":
5,
'lines': [{
'cost': 15,
'tva': 20,
'description': u'description',
'unity': u"Mètre",
"quantity": 5,
"order": 2,
}]
}]
}
expected_value = {
'line_groups': [{
'task_id':
5,
'title':
u"title",
'description':
u"description",
"order":
5,
'lines': [{
'cost': 1500000,
'tva': 2000,
'description': u'description',
'unity': u"Mètre",
"quantity": 5.0,
"order": 2,
}]
}]
}
assert schema.deserialize(value) == expected_value
def test_estimation_deposit():
from autonomie.models.task.estimation import Estimation
schema = SQLAlchemySchemaNode(Estimation, includes=('deposit', ))
schema = schema.bind()
value = {'deposit': 15}
assert schema.deserialize(value) == value
value = {'deposit': 150}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
value = {'deposit': -1}
with pytest.raises(colander.Invalid):
schema.deserialize(value)
def test_dictify_with_null(self):
""" Test SQLAlchemySchemaNode.dictify(obj) with null values
and show that result is a valid appstruct for the given schema
"""
Base = declarative_base()
class Sensor(Base):
__tablename__ = 'sensor'
sensor_id = Column(Integer, primary_key=True)
institution_id = Column(Integer, nullable=True)
sensor_label = Column(String, nullable=True)
sensor = Sensor(
sensor_id=3,
institution_id=None,
sensor_label=None,
)
schema = SQLAlchemySchemaNode(Sensor)
appstruct = schema.dictify(sensor)
cstruct = schema.serialize(appstruct=appstruct)
newappstruct = schema.deserialize(cstruct)
newobj = schema.objectify(appstruct)
self.assertEqual(appstruct, newappstruct)
self.assertEqual(sensor.sensor_id, newobj.sensor_id)
self.assertEqual(sensor.institution_id, newobj.institution_id)
self.assertEqual(sensor.sensor_label, newobj.sensor_label)
def test_null_issues(self):
""" Make sure nullable values are set properly when null
#42 introduced an issue where values may not have been properly
set if the value is supposed to be set to null
"""
Base = declarative_base()
class Person(Base):
__tablename__ = 'person'
id = Column(Integer, primary_key=True)
fullname = Column(String, nullable=True)
age = Column(Integer, nullable=True)
schema = SQLAlchemySchemaNode(Person)
person = Person(
id=7,
fullname="Joe Smith",
age=35,
)
# dict coming from a form submission
update_cstruct = {
'id': '7',
'fullname': '',
'age': '',
}
update_appstruct = schema.deserialize(update_cstruct)
schema.objectify(update_appstruct, context=person)
self.assertEqual(person.id, 7)
self.assertEqual(person.fullname, None)
self.assertEqual(person.age, None)
def test_payment(mode, tva, bank):
from autonomie.models.task.invoice import Payment
schema = SQLAlchemySchemaNode(Payment)
schema = schema.bind()
value = {
'mode': mode.label,
"amount": 12.5,
"remittance_amount": u"Remittance",
"date": NOW.isoformat(),
"tva_id": tva.id,
"bank_id": bank.id,
"user_id": 5,
"task_id": 5,
}
expected_value = {
'mode': mode.label,
"amount": 1250000,
"remittance_amount": u"Remittance",
"date": NOW,
"tva_id": tva.id,
"bank_id": bank.id,
"user_id": 5,
"task_id": 5,
}
result = schema.deserialize(value)
for key, value in expected_value.items():
assert result[key] == value
def statistic_sheet_add_edit_view(context, request):
"""
View for adding editing statistics sheets
"""
logger.info("Here we are")
logger.info(request.POST)
if 'title' in request.POST:
schema = SQLAlchemySchemaNode(StatisticSheet, includes=('title',))
try:
appstruct = schema.deserialize(request.POST)
except colander.Invalid:
logger.exception(u"Erreur à la création de la feuille de \
statistiques")
else:
if context.__name__ == 'statistic_sheet':
sheet = schema.objectify(appstruct, context)
sheet = request.dbsession.merge(sheet)
else:
sheet = schema.objectify(appstruct)
request.dbsession.add(sheet)
request.dbsession.flush()
url = request.route_path('statistic', id=sheet.id)
return HTTPFound(url)
logger.debug(u"Invalid datas have been passed")
raise HTTPClientError()
logger.debug(u"Missing datas in the request")
raise HTTPClientError()
def test_default_clause(self):
"""Test proper handling of default and server_default values
"""
Base = declarative_base()
def give_me_three():
return 3
class Patient(Base):
__tablename__ = 'patient'
# default= is equivalent to ColumnDefault()
# server_default= is equivalent to DefaultClause()
id = Column(BigInteger(unsigned=True), default=text("uuid_short()"), primary_key=True, autoincrement=False)
received_timestamp = Column(TIMESTAMP, server_default=func.now(), nullable=False)
some_number = Column(Integer, DefaultClause('3'), nullable=False)
scalar_number = Column(Integer, default=3, nullable=False)
pyfunc_test = Column(Integer, default=give_me_three, nullable=False)
schema = SQLAlchemySchemaNode(Patient)
'''
Conceivably you should be able to test DefaultClause for a
scalar type value and use it as a default/missing in Colander.
However, the value is interpreted by the backend engine and
could be a interpreted by it in an unexpected way. For this
reason we drop the value and let the backend handle it.
'''
# from <FORM> result into SQLA; tests missing
self.assertEqual(schema['id'].missing, colander.drop)
self.assertEqual(schema['received_timestamp'].missing, colander.drop)
self.assertEqual(schema['some_number'].missing, colander.drop)
self.assertEqual(schema['scalar_number'].missing, 3)
self.assertEqual(schema['pyfunc_test'].missing, 3)
deserialized = schema.deserialize({})
self.assertIn('scalar_number', deserialized)
self.assertEqual(deserialized['scalar_number'], 3)
self.assertIn('pyfunc_test', deserialized)
self.assertEqual(deserialized['pyfunc_test'], 3)
# from SQLA result into <FORM>; tests default
self.assertEqual(schema['id'].default, colander.null)
self.assertEqual(schema['received_timestamp'].default, colander.null)
self.assertEqual(schema['some_number'].default, colander.null)
self.assertEqual(schema['scalar_number'].default, 3)
self.assertEqual(schema['pyfunc_test'].default, 3)
serialized = schema.serialize({})
self.assertIn('id', serialized)
self.assertEqual(serialized['id'], colander.null)
self.assertIn('received_timestamp', serialized)
self.assertEqual(serialized['received_timestamp'], colander.null)
self.assertIn('some_number', serialized)
self.assertEqual(serialized['some_number'], colander.null)
self.assertIn('scalar_number', serialized)
self.assertEqual(serialized['scalar_number'], str(3))
self.assertIn('pyfunc_test', serialized)
self.assertEqual(serialized['pyfunc_test'], str(3))
def test_missing_mapping_configuration(self):
""" Test to check ``missing`` is set to an SQLAlchemy-suitable value.
"""
schema = SQLAlchemySchemaNode(Account)
self.assertEqual(schema['person_id'].missing, colander.null)
self.assertEqual(schema['person'].missing, [])
deserialized = schema.deserialize({'email': '*****@*****.**',
'timeout': '09:44:33'})
self.assertEqual(deserialized['person_id'], colander.null)
self.assertEqual(deserialized['person'], [])
def test_defaultmissing_primarykey(self):
"""Ensure proper handling of empty values on primary keys
"""
Base = declarative_base()
class User(Base):
__tablename__ = 'user'
# the follwing is automatically made autoincrement=True
id = Column(Integer, primary_key=True)
schema = SQLAlchemySchemaNode(User)
# from <FORM> result into SQLA; tests missing
self.assertEqual(schema['id'].missing, colander.drop)
deserialized = schema.deserialize({})
self.assertNotIn('id', deserialized)
# from SQLA result into <FORM>; tests default
self.assertEqual(schema['id'].default, colander.null)
serialized = schema.serialize({})
self.assertIn('id', serialized)
self.assertEqual(serialized['id'], colander.null)
class Widget(Base):
__tablename__ = 'widget'
id = Column(String, primary_key=True)
schema = SQLAlchemySchemaNode(Widget)
# from <FORM> result into SQLA; tests missing
self.assertEqual(schema['id'].missing, colander.required)
self.assertRaises(colander.Invalid, schema.deserialize, {})
# from SQLA result into <FORM>; tests default
self.assertEqual(schema['id'].default, colander.null)
serialized = schema.serialize({})
self.assertIn('id', serialized)
self.assertEqual(serialized['id'], colander.null)
