def testDiffMultipleElement(self):
"""diff between 2 modelfiles with a MultipleElement"""
model = ModelFile()
model.add_element('name', check='string', multiple=True)
model2 = model.emptycopy()
# Empty models have no difference
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Same model have no difference
model.add('name', 'foo')
model2.add('name', 'foo')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Add a value
model2.add('name', 'bar')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {'name': ['bar']})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Remove a value
del model2['name']
model.add('name', 'bar')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {'name': ['foo', 'bar']})
self.assertEqual(changed.as_dict(), {})
def testDiffMultipleElement(self):
"""diff between 2 modelfiles with a MultipleElement"""
model = ModelFile()
model.add_element('name', check='string', multiple=True)
model2 = model.emptycopy()
# Empty models have no difference
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Same model have no difference
model.add('name', 'foo')
model2.add('name', 'foo')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Add a value
model2.add('name', 'bar')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {'name': ['bar']})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Remove a value
del model2['name']
model.add('name', 'bar')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {'name': ['foo', 'bar']})
self.assertEqual(changed.as_dict(), {})
def testModelBaseMethods(self):
"""test ModelFile base methods"""
model = ModelFile()
# content() with a default value
self.assertEqual(model.content('default'), 'default')
model.add_element('foo', check='string', multiple=True)
# get() with a default value
self.assertEqual(model.get('foo', 'default'), 'default')
# Only key with non-empty value are taken in account
self.assertEqual(len(model), 0)
# parse()
self.assertRaises(ModelFileValueError, model.parse, "foo one two")
# __contains__() False
self.assertFalse('foo' in model)
# iter()
model.add('foo', "5 6")
model.add('foo', "6 7")
self.assertEqual(list(iter(model)), ['foo'])
# __contains__() True
self.assertTrue('foo' in model)
def testMultipleElement(self):
"""ModelFile with MultipleElement"""
model = ModelFile()
model.add_element('foos', check='digit', multiple=True)
# Default
self.assertEqual(model.get('foos', []), [])
# Multiple add()
model.add('foos', 3)
self.assertEqual(model.get('foos'), [3])
self.assertEqual(str(model), "foos:3")
model.add('foos', 5)
self.assertEqual(model.get('foos'), [3, 5])
self.assertEqual(str(model), "foos:3\nfoos:5")
def testMultipleElement(self):
"""ModelFile with MultipleElement"""
model = ModelFile()
model.add_element('foos', check='digit', multiple=True)
# Default
self.assertEqual(model.get('foos', []), [])
# Multiple add()
model.add('foos', 3)
self.assertEqual(model.get('foos'), [3])
self.assertEqual(str(model), "foos:3")
model.add('foos', 5)
self.assertEqual(model.get('foos'), [3, 5])
self.assertEqual(str(model), "foos:3\nfoos:5")
def testModelBaseMethods(self):
"""test ModelFile base methods"""
model = ModelFile()
# content() with a default value
self.assertEqual(model.content('default'), 'default')
model.add_element('foo', check='string', multiple=True)
# get() with a default value
self.assertEqual(model.get('foo', 'default'), 'default')
# Only key with non-empty value are taken in account
self.assertEqual(len(model), 0)
# parse() bad syntax
self.assertRaises(ModelFileValueError, model.parse, "foo one two")
# parse() with good syntax, but unknown key
self.assertRaises(ModelFileValueError, model.parse, "good: syntax")
# __contains__() False
self.assertFalse('foo' in model)
# iter()
model.add('foo', "5 6")
model.add('foo', "6 7")
self.assertEqual(list(iter(model)), ['foo'])
# __contains__() True
self.assertTrue('foo' in model)
# replace()
model.replace('foo', "other")
self.assertEqual(model.get('foo'), ['other'])
# __eq__()
other = model.emptycopy()
self.assertNotEqual(model, other)
other.add("foo", "other")
self.assertEqual(model, other)
self.assertNotEqual(model, "bad type object")
def testModelBaseMethods(self):
"""test ModelFile base methods"""
model = ModelFile()
# content() with a default value
self.assertEqual(model.content('default'), 'default')
model.add_element('foo', check='string', multiple=True)
# get() with a default value
self.assertEqual(model.get('foo', 'default'), 'default')
# Only key with non-empty value are taken in account
self.assertEqual(len(model), 0)
# parse() bad syntax
self.assertRaises(ModelFileValueError, model.parse, "foo one two")
# parse() with good syntax, but unknown key
self.assertRaises(ModelFileValueError, model.parse, "good: syntax")
# __contains__() False
self.assertFalse('foo' in model)
# iter()
model.add('foo', "5 6")
model.add('foo', "6 7")
self.assertEqual(list(iter(model)), ['foo'])
# __contains__() True
self.assertTrue('foo' in model)
# replace()
model.replace('foo', "other")
self.assertEqual(model.get('foo'), ['other'])
# __eq__()
other = model.emptycopy()
self.assertNotEqual(model, other)
other.add("foo", "other")
self.assertEqual(model, other)
self.assertNotEqual(model, "bad type object")
def testDiffSimpleElement(self):
"""diff between 2 modelfiles with a SimpleElement"""
model = ModelFile()
model.add_element('name', check='string')
model2 = model.emptycopy()
# Empty models have no difference
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Same model have no difference
model.add('name', 'foo')
model2.add('name', 'foo')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# A value changed
del model2['name']
model2.add('name', 'bar')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {'name': 'bar'})
# A value added
del model['name']
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {'name': 'bar'})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# A value removed
added, changed, removed = model2.diff(model)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {'name': 'bar'})
self.assertEqual(changed.as_dict(), {})
def testDiffSimpleElement(self):
"""diff between 2 modelfiles with a SimpleElement"""
model = ModelFile()
model.add_element('name', check='string')
model2 = model.emptycopy()
# Empty models have no difference
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# Same model have no difference
model.add('name', 'foo')
model2.add('name', 'foo')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# A value changed
del model2['name']
model2.add('name', 'bar')
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {'name': 'bar'})
# A value added
del model['name']
added, changed, removed = model.diff(model2)
self.assertEqual(added.as_dict(), {'name': 'bar'})
self.assertEqual(removed.as_dict(), {})
self.assertEqual(changed.as_dict(), {})
# A value removed
added, changed, removed = model2.diff(model)
self.assertEqual(added.as_dict(), {})
self.assertEqual(removed.as_dict(), {'name': 'bar'})
self.assertEqual(changed.as_dict(), {})
def testAddCustomElement(self):
"""model file uses a user-defined Element"""
class ElemNodeSet(SimpleElement):
def __init__(self, check='string', default=None, values=None):
SimpleElement.__init__(self, 'string', default, values)
def _validate(self, value):
try:
return NodeSet(value)
except:
raise ModelFileValueError
model = ModelFile()
model.add_custom('nodes', ElemNodeSet(), multiple=True)
model.add_custom('nids', ElemNodeSet(), multiple=True)
model.add('nodes', 'foo[1-5]')
self.assertEqual(str(model), "nodes:foo[1-5]")
self.assertEqual([str(item) for item in model.get('nodes')],
[str(NodeSet('foo[1-5]'))])
self.assertRaises(ModelFileValueError, model.add, 'nodes', 'bad[15')
def testAddCustomElement(self):
"""model file uses a user-defined Element"""
class ElemNodeSet(SimpleElement):
def __init__(self, check='string', default=None, values=None):
SimpleElement.__init__(self, 'string', default, values)
def _validate(self, value):
try:
return NodeSet(value)
except:
raise ModelFileValueError
model = ModelFile()
model.add_custom('nodes', ElemNodeSet(), multiple=True)
model.add_custom('nids', ElemNodeSet(), multiple=True)
model.add('nodes', 'foo[1-5]')
self.assertEqual(str(model), "nodes:foo[1-5]")
self.assertEqual([str(item) for item in model.get('nodes')],
[str(NodeSet('foo[1-5]'))])
self.assertRaises(ModelFileValueError, model.add, 'nodes', 'bad[15')
def testModelStandardElement(self):
"""ModelFile with simple Element"""
model = ModelFile()
# Type string
model.add_element('name', check='string')
self.assertEqual(model.get('name', 'mine'), 'mine')
model.add('name', 'foo')
self.assertEqual(model.get('name'), 'foo')
self.assertEqual(str(model), "name:foo")
# Default value
model.add_element('bar', check='string', default='barbar')
self.assertEqual(model.get('bar'), 'barbar')
self.assertEqual(model.get('bar', 'mine'), 'barbar')
# Default value are not used for string representation
self.assertEqual(str(model), "name:foo")
# Type digit
model.add_element('stripe_count', check='digit', default=1)
self.assertEqual(model.get('stripe_count'), 1)
model.add('stripe_count', 2)
self.assertEqual(model.get('stripe_count'), 2)
self.assertEqual(str(model), "name:foo\nstripe_count:2")
def testModelStandardElement(self):
"""ModelFile with simple Element"""
model = ModelFile()
# Type string
model.add_element('name', check='string')
self.assertEqual(model.get('name', 'mine'), 'mine')
model.add('name', 'foo')
self.assertEqual(model.get('name'), 'foo')
self.assertEqual(str(model), "name:foo")
# Default value
model.add_element('bar', check='string', default='barbar')
self.assertEqual(model.get('bar'), 'barbar')
self.assertEqual(model.get('bar', 'mine'), 'barbar')
# Default value are not used for string representation
self.assertEqual(str(model), "name:foo")
# Type digit
model.add_element('stripe_count', check='digit', default=1)
self.assertEqual(model.get('stripe_count'), 1)
model.add('stripe_count', 2)
self.assertEqual(model.get('stripe_count'), 2)
self.assertEqual(str(model), "name:foo\nstripe_count:2")
