def test_loadFromItem(self):
item = _DummyItem(i=55, t=u'lulz')
model = Model(params=[Value.fromAttr(_DummyItem.i),
Value.fromAttr(_DummyItem.t)])
loadFromItem(model, item)
self.assertEqual(model.params['i'].value, item.i)
self.assertEqual(model.params['t'].value, item.t)
def test_processing(self):
model = Model(params=[
Value(name='foo', value=4),
Value(name='bar', value=u'quux')
])
result = model.process()
self.assertEquals(result, dict(foo=4, bar=u'quux'))
def test_repr(self):
"""
L{methanal.model.Value} has a useful human-readable representation.
"""
self.assertEquals(repr(Value(name='foo', value=u'bar')),
"<Value name='foo' value=u'bar' doc=u'foo'>")
self.assertEquals(repr(Value(name='foo', value=u'bar', doc=u'Hello')),
"<Value name='foo' value=u'bar' doc=u'Hello'>")
def test_attachMany(self):
model = Model()
p1 = Value(name='foo')
p2 = Value(name='bar')
model.attach(p1, p2)
self.assertIdentical(model.params['foo'], p1)
self.assertIdentical(model.params['bar'], p2)
def setUp(self):
s = self.store = Store()
installOn(WebSite(store=s), s)
self.model = Model(params=[
Value(name='foo', value=4),
Value(name='bar', value=u'quux')
])
def test_loadFromItem(self):
item = _DummyItem(i=55, t=u'lulz')
model = Model(params=[
Value.fromAttr(_DummyItem.i),
Value.fromAttr(_DummyItem.t)
])
loadFromItem(model, item)
self.assertEqual(model.params['i'].value, item.i)
self.assertEqual(model.params['t'].value, item.t)
def test_constraints(self):
def _constraint(value):
if value != 5:
return u'Value must be 5'
param = Value(name='param')
param._constraint = constraint(_constraint)
self.assertFalse(param.isValid(4))
self.assertTrue(param.isValid(5))
model = Model([param])
param.value = 3
self.assertRaises(errors.ConstraintError, model.process)
def test_constraints(self):
def _constraint(value):
if value != 5:
return u'Value must be 5'
param = Value(name='param')
param._constraint = constraint(_constraint)
self.assertFalse(param.isValid(4))
self.assertTrue(param.isValid(5))
model = Model([param])
param.value = 3
self.assertRaises(errors.ConstraintError, model.process)
def createParam(self, args):
"""
Create a model parameter.
"""
return Value(self.name)
def test_valueParam(self):
param = Value.fromAttr(_DummyItem.t)
self.assertIdentical(type(param), Value)
self.assertEqual(param.name, 't')
self.assertEqual(param.value, None)
self.assertEqual(param.doc, 'param t')
def test_valueParamNoDoc(self):
param = Value.fromAttr(_DummyItem.i)
self.assertIdentical(type(param), Value)
self.assertEqual(param.name, 'i')
self.assertEqual(param.value, 5)
self.assertEqual(param.doc, 'i')
def test_attach(self):
model = Model()
p = Value(name='foo')
model.attach(p)
self.assertIdentical(model.params['foo'], p)
class AutoSchemaTests(TestCase):
expectedParams = {
'i': (Value(name='i', doc=u'i'), 5, 5),
't': (Value(name='t', doc=u'param t'), None, u'text'),
'tl': (List(name='tl', doc=u'param tl'), None, [u'text1', u'text2']),
}
def setUp(self):
self.store = Store()
def test_schemaAnalysis(self):
"""
Test that parameters are correctly synthesized from an Item schema.
"""
store = Store()
model = ItemModel(itemClass=_DummyItem, store=store)
params = model.params
self.assertEquals(params.keys(), self.expectedParams.keys())
for k in params:
p1 = params[k]
p2, classDefault, itemDefault = self.expectedParams[k]
self.assertIdentical(type(p1), type(p2))
self.assertEquals(p1.name, p2.name)
self.assertEquals(p1.value, classDefault)
self.assertEquals(p1.doc, p2.doc)
def test_schemaIgnore(self):
"""
Test that ignoredAttributes is respected.
"""
store = Store()
model = ItemModel(itemClass=_DummyItem,
store=store,
ignoredAttributes=set(['tl']))
params = model.params
self.assertNotIn('tl', params)
def test_itemAnalysis(self):
dummyItem = _DummyItem(store=self.store,
i=5,
t=u'text',
tl=[u'text1', u'text2'])
model = ItemModel(item=dummyItem)
params = model.params
for k in params:
p1 = params[k]
p2, classDefault, itemDefault = self.expectedParams[k]
self.assertEquals(p1.value, itemDefault)
def test_itemCreation(self):
model = ItemModel(itemClass=_DummyItem, store=self.store)
model.params['i'].value = 7
model.params['t'].value = u'foo'
self.assertIdentical(model.item, None)
model.process()
self.assertEquals(model.item.i, 7)
self.assertEquals(model.item.t, u'foo')
def test_itemEditing(self):
model = ItemModel(item=_DummyItem(store=self.store))
model.params['i'].value = 7
model.params['t'].value = u'foo'
model.process()
self.assertEquals(model.item.i, 7)
self.assertEquals(model.item.t, u'foo')
def test_referenceAttributeCreating(self):
dummyParent = _DummyParentItem(store=self.store, r=None)
model = ItemModel(dummyParent)
self.assertIdentical(dummyParent.r, None)
model.process()
self.assertEquals(dummyParent.r.i, 5)
def test_referenceAttributeEditing(self):
dummyChild = _DummyChildItem(store=self.store, i=5)
dummyParent = _DummyParentItem(store=self.store, r=dummyChild)
model = ItemModel(dummyParent)
self.assertIdentical(dummyParent.r, dummyChild)
model.params['r'].model.params['i'].value = 6
model.process()
self.assertIdentical(dummyParent.r, dummyChild)
self.assertEquals(dummyChild.i, 6)
def test_noRefType(self):
"""
Attempting to automatically synthesise a model for an Item with a
C{reference} attribute with no C{'reftype'} raises C{ValueError}.
"""
brokenParent = _BrokenReference(store=self.store)
self.assertRaises(ValueError, ItemModel, brokenParent)
def test_valueParam(self):
param = Value.fromAttr(_DummyItem.t)
self.assertIdentical(type(param), Value)
self.assertEqual(param.name, 't')
self.assertEqual(param.value, None)
self.assertEqual(param.doc, 'param t')
def test_valueParamNoDoc(self):
param = Value.fromAttr(_DummyItem.i)
self.assertIdentical(type(param), Value)
self.assertEqual(param.name, 'i')
self.assertEqual(param.value, 5)
self.assertEqual(param.doc, 'i')
