def test_unicode_io(self):
"""
Tests that unicode is saved and retrieved properly
"""
tm1 = TestVertexModel.create(test_val=9, name=u'test2')
tm2 = TestVertexModel.get(tm1._id)
tm1.delete()
def test_all_method_invalid_length(self):
v1 = TestVertexModel.create()
v2 = TestVertexModel.create()
from mogwai.exceptions import MogwaiQueryError
with self.assertRaises(MogwaiQueryError):
TestVertexModel.all([v1.id, v2.id, 'invalid'])
v1.delete()
v2.delete()
def test_success_case(self):
""" Tests that the update method works as expected """
tm = TestVertexModel.create(test_val=8, name='123456789')
tm2 = tm.update(test_val=9)
tm3 = TestVertexModel.get(tm.id)
self.assertEqual(tm2.test_val, 9)
self.assertEqual(tm3.test_val, 9)
tm.delete()
def test_model_deleting_works_properly(self):
"""
Tests that an instance's delete method deletes the instance
"""
tm = TestVertexModel.create(test_val=8, name='123456789')
vid = tm.id
tm.delete()
with self.assertRaises(TestVertexModel.DoesNotExist):
tm2 = TestVertexModel.get(vid)
def test_value_managers_are_keeping_model_instances_isolated(self):
"""
Tests that instance value managers are isolated from other instances
"""
inst1 = TestVertexModel(test_val=5)
inst2 = TestVertexModel(test_val=7)
self.assertNotEquals(inst1.test_val, inst2.test_val)
self.assertEquals(inst1.test_val, 5)
self.assertEquals(inst2.test_val, 7)
def test_reload(self):
""" Tests that and instance's reload method does an inplace update of the instance """
tm0 = TestVertexModel.create(test_val=8, name='123456789')
tm1 = TestVertexModel.get(tm0.id)
tm1.test_val = 7
tm1.save()
tm0.reload()
self.assertEqual(tm0.test_val, 7)
tm0.delete()
def test_get_by_id(self):
v1 = TestVertexModel.create()
results = TestVertexModel.get(v1.id)
self.assertIsInstance(results, TestVertexModel)
self.assertEqual(results, v1)
with self.assertRaises(TestEdgeModel.DoesNotExist):
results = TestVertexModel.get(None)
with self.assertRaises(TestEdgeModel.DoesNotExist):
results = TestVertexModel.get('nonexistant')
v2 = TestVertexModel2.create(test_val=0)
with self.assertRaises(TestVertexModel.WrongElementType):
results = TestVertexModel.get(v2.id)
v2.delete()
v1.delete()
def test_manual_properties(self):
v = TestVertexModel.create(test_val=1, name='Test 7', some_property=32)
print_("Got Results: {}".format(v))
print_("Result dict: {}".format(v.as_dict()))
print_("\tResult properties: {}".format(v._properties.keys()))
print_("\tResult Manaul: {}".format(v._manual_values.items()))
self.assertEqual(v['some_property'], 32)
self.assertIn('some_property', v) # This also tests __contains__
self.assertIn('test_val', v) # This also tests __contains__
# test len(Element()), should return len(element._properties) + len(element._manual_values)
self.assertEqual(len(v), 3)
# test __iter__
prop_keys = [key for key in v]
self.assertEqual(len(prop_keys), 3)
for prop_key in v:
self.assertIn(prop_key, ['test_val', 'name', 'some_property'])
# test keys()
self.assertEqual(len(prop_keys), len(v.keys()))
for prop_key in v.keys():
self.assertIn(prop_key, prop_keys)
# test values()
prop_values = v.values()
self.assertEqual(len(prop_values), 3)
for prop_value in prop_values:
self.assertIn(prop_value, [1, 'Test 7', 32])
# test items()
prop_items = v.items()
self.assertEqual(len(prop_items), 3)
for prop_key, prop_value in prop_items:
self.assertIn(prop_key, ['test_val', 'name', 'some_property'])
self.assertIn(prop_value, [1, 'Test 7', 32])
# test change
v['some_property'] = 42
self.assertEqual(v['some_property'], 42)
v.save()
self.assertEqual(v['some_property'], 42)
# test delete
del v['some_property']
# This should still exist, so the property can be removed from the database,
# but should raise an AttributeError if attempted to access normally
self.assertIn('some_property', v)
self.assertIsNone(v._manual_values.get('some_property'))
with self.assertRaises(AttributeError):
value = v['some_property']
print_("Got value: {}".format(value))
v.delete()
def test_model_save_and_load(self):
"""
Tests that models can be saved and retrieved
"""
tm0 = TestVertexModel.create(test_val=8, name='123456789')
tm1 = TestVertexModel.create(test_val=9, name='456789')
tms = TestVertexModel.all([tm0.id, tm1.id])
self.assertEqual(len(tms), 2)
for pname in tm0._properties.keys():
self.assertEquals(getattr(tm0, pname), getattr(tms[0], pname))
tms = TestVertexModel.all([tm1.id, tm0.id])
self.assertEqual(tms[0].id, tm1.id)
self.assertEqual(tms[1].id, tm0.id)
tm0.delete()
tm1.delete()
def test_multiple_edge_traversal_with_type_filtering(self):
""" Tests that using multiple edges for traversals works """
v = TestVertexModel.create(test_val=1, name='Test1')
v1 = TestVertexModel.create()
e1 = TestEdgeModel.create(v, v1)
v2 = TestVertexModel.create()
e2 = OtherTestEdge.create(v, v2)
v3 = TestVertexModel.create()
e3 = YetAnotherTestEdge.create(v, v3)
v4 = OtherTestModel.create()
e4 = TestEdgeModel.create(v, v4)
v5 = OtherTestModel.create()
e5 = OtherTestEdge.create(v, v5)
v6 = OtherTestModel.create()
e6 = YetAnotherTestEdge.create(v, v6)
self.assertEqual(len(v.outV()), 6)
self.assertEqual(len(v.outV(TestEdgeModel, OtherTestEdge)), 4)
self.assertEqual(len(v.outV(TestEdgeModel, OtherTestEdge, types=[TestVertexModel])), 2)
e1.delete()
e2.delete()
e3.delete()
e4.delete()
e5.delete()
e6.delete()
v.delete()
v1.delete()
v2.delete()
v3.delete()
v4.delete()
v5.delete()
v6.delete()
def test_delete_methods(self):
v1 = TestVertexModel.create()
v2 = TestVertexModel.create()
# delete_outE
e1 = TestEdgeModel.create(v1, v2)
v1.delete_outE(TestEdgeModel)
# delete_inE
e1 = TestEdgeModel.create(v1, v2)
v2.delete_inE(TestEdgeModel)
# delete_inV
e1 = TestEdgeModel.create(v1, v2)
v1.delete_inV(TestEdgeModel)
# delete_outV
v2 = TestVertexModel.create()
e1 = TestEdgeModel.create(v1, v2)
v2.delete_outV(TestEdgeModel)
v2.delete()
def test_model_updating_works_properly(self):
"""
Tests that subsequent saves after initial model creation work
"""
tm = TestVertexModel.create(test_val=8, name='123456789')
tm.test_val = 100
tm.save()
tm.test_val = 80
tm.save()
tm.test_val = 60
tm.save()
tm.test_val = 40
tm.save()
tm.test_val = 20
tm.save()
tm2 = TestVertexModel.get(tm.id)
self.assertEquals(tm.test_val, tm2.test_val)
tm.delete()
def test_graph_property_attributes_handled_correctly(self):
"""
Tests that graph property attributes are moved to a _properties dict and replaced with simple value attributes
"""
#check class attributes
self.assertHasAttr(TestVertexModel, '_properties')
self.assertHasAttr(TestVertexModel, 'name')
self.assertHasAttr(TestVertexModel, 'test_val')
#check instance attributes
inst = TestVertexModel()
self.assertHasAttr(inst, 'name')
self.assertHasAttr(inst, 'test_val')
self.assertIsNone(inst.name)
self.assertIsNone(inst.test_val)
def test_find_by_value_method(self):
v1 = TestVertexModel.create(name='v1', test_val=-99)
v2 = TestVertexModel.create(name='v2', test_val=-99)
v3 = TestVertexModelDouble.create(name='v3', test_val=-100.0)
self.assertEqual(len(TestVertexModel.find_by_value('name', 'v1')), 1)
self.assertEqual(len(TestVertexModel.find_by_value('test_val', -99)), 2)
self.assertEqual(len(TestVertexModel.find_by_value('name', 'bar')), 0)
self.assertEqual(TestVertexModel.find_by_value('name', 'v1')[0], v1)
self.assertEqual(len(TestVertexModelDouble.find_by_value('test_val', -100.0)), 1)
v1.delete()
v2.delete()
v3.delete()
def setUpClass(cls):
super(GraphRelationshipBaseTestCase, cls).setUpClass()
cls.relationship_base_cls = Relationship
cls.edge_model = TestEdgeModel
cls.vertex_model = TestVertexModel
cls.vertex_start = TestVertexModel.create(name='test relationship')
def setUpClass(cls):
super(GraphRelationshipBaseTestCase, cls).setUpClass()
cls.relationship_base_cls = Relationship
cls.edge_model = TestEdgeModel
cls.vertex_model = TestVertexModel
cls.vertex_start = TestVertexModel.create(name='test relationship')
def setUp(self):
super(TestEdgeIO, self).setUp()
self.v1 = TestVertexModel.create(test_val=8, name='a')
self.v2 = TestVertexModel.create(test_val=7, name='b')
def setUp(self):
super(TestEdgeIO, self).setUp()
self.v1 = TestVertexModel.create(test_val=8, name='a')
self.v2 = TestVertexModel.create(test_val=7, name='b')
def test_proper_table_naming(self):
self.assertEqual(TestVertexModel.element_type, 'test_vertex_model')
self.assertEqual(TestVertexModel.get_element_type(), 'test_vertex_model')
def test_unknown_names_raise_exception(self):
""" Tests that passing in names for columns that don't exist raises an exception """
tm = TestVertexModel.create(test_val=8, text='123456789')
with self.assertRaises(TypeError):
tm.update(jon='beard')
tm.delete()
def test_all_method(self):
with self.assertRaises(MogwaiQueryError):
TestVertexModel.all(1)
def setUp(self):
super(TestVertexTraversal, self).setUp()
self.v1 = TestVertexModel.create(test_val=1, name='Test1')
self.v2 = TestVertexModel.create(test_val=2, name='Test2')
self.v3 = OtherTestModel.create(test_val=3, name='Test3')
self.v4 = OtherTestModel.create(test_val=3, name='Test3')
