def test_loaded(self):
spec = connection.generate_spec()
self.assertIsInstance(spec, (list, tuple))
self.assertGreater(len(spec), 0)
for s in spec:
print_(s)
self.assertIsInstance(s, dict)
self.assertDictContainsKeyWithValueType(s, 'model', string_types)
self.assertDictContainsKeyWithValueType(s, 'element_type',
string_types)
self.assertDictContainsKeyWithValueType(s, 'makeType',
string_types)
self.assertDictContainsKeyWithValueType(s, 'properties', dict)
for pk, pv in s['properties'].items():
self.assertDictContainsKeyWithValueType(
pv, 'data_type', string_types)
self.assertDictContainsKeyWithValueType(
pv, 'index_ext', string_types)
self.assertDictContainsKeyWithValueType(
pv, 'uniqueness', string_types)
self.assertDictContainsKeyWithValueType(pv, 'compiled', dict)
self.assertDictContainsKeyWithValueType(
pv['compiled'], 'script', string_types)
self.assertDictContainsKeyWithValueType(
pv['compiled'], 'params', dict)
self.assertDictContainsKeyWithValueType(
pv['compiled'], 'transaction', bool)
def test_validation(self):
for case in self.good_cases:
print_("testing good case: %s" % (case, ))
self.assertNotRaise(self.klass.validate, case)
for case in self.bad_cases:
print_("testing bad case: %s" % (case, ))
self.assertRaises(ValidationError, self.klass.validate, case)
def send_metrics(self, *args, **kwargs):
""" Default pyformance implementation is to dump all metrics to STDOUT
Change this if you want to customize for a particular metric collection system, ie. graphite, newrelic, etc.
"""
timestamp, metrics = self.get_metrics()
if metrics:
print_("{}: {}".format(timestamp, metrics))
def send_metrics(self, *args, **kwargs):
""" Default pyformance implementation is to dump all metrics to STDOUT
Change this if you want to customize for a particular metric collection system, ie. graphite, newrelic, etc.
"""
timestamp, metrics = self.get_metrics()
if metrics:
print_("{}: {}".format(timestamp, metrics))
def test_gremlin_table_row(self):
d = OrderedDict({'test': 1, 'a': 'b', 'c': 3})
r = Row(deepcopy(d))
print_(r)
self.assertDictEqual(d, r._Row__data)
self.assertEqual(len(d), len(r))
# test tuple-like access
self.assertIn(r[0], d.values())
self.assertListEqual(list(d.values()), list(r[:]))
with self.assertRaises(MogwaiException):
r[0] = 'test'
with self.assertRaises(MogwaiException):
r[:] = (1, 2, 3)
with self.assertRaises(MogwaiException):
del r[0]
with self.assertRaises(MogwaiException):
del r[0:2]
# test dict-like access
self.assertListEqual(list(d.values()), list(r.values()))
self.assertListEqual(list(d.keys()), list(r.keys()))
self.assertListEqual(list(d.items()), list(r.items()))
self.assertEqual(d['test'], r['test'])
self.assertEqual(d['a'], r['a'])
self.assertEqual(d['c'], r['c'])
with self.assertRaises(MogwaiException):
r['test'] = 0
with self.assertRaises(MogwaiException):
del r['test']
# test . notation access
self.assertEqual(d['test'], r.test)
self.assertEqual(d['a'], r.a)
self.assertEqual(d['c'], r.c)
with self.assertRaises(MogwaiException):
r.test = 0
with self.assertRaises(MogwaiException):
del r.test
# test iteration
self.assertEqual(len(d), len([v for v in r]))
self.assertListEqual(list(d.values()), [v for v in r])
# test next
self.assertIn(r.next(), d.values())
self.assertIn(r.next(), d.values())
self.assertIn(r.next(), d.values())
# test equality
r2 = Row(deepcopy(d))
self.assertEqual(r, r2)
def test_gremlin_table_row(self):
d = OrderedDict({"test": 1, "a": "b", "c": 3})
r = Row(deepcopy(d))
print_(r)
self.assertDictEqual(d, r._Row__data)
self.assertEqual(len(d), len(r))
# test tuple-like access
self.assertIn(r[0], d.values())
self.assertListEqual(list(d.values()), list(r[:]))
with self.assertRaises(MogwaiException):
r[0] = "test"
with self.assertRaises(MogwaiException):
r[:] = (1, 2, 3)
with self.assertRaises(MogwaiException):
del r[0]
with self.assertRaises(MogwaiException):
del r[0:2]
# test dict-like access
self.assertListEqual(list(d.values()), list(r.values()))
self.assertListEqual(list(d.keys()), list(r.keys()))
self.assertListEqual(list(d.items()), list(r.items()))
self.assertEqual(d["test"], r["test"])
self.assertEqual(d["a"], r["a"])
self.assertEqual(d["c"], r["c"])
with self.assertRaises(MogwaiException):
r["test"] = 0
with self.assertRaises(MogwaiException):
del r["test"]
# test . notation access
self.assertEqual(d["test"], r.test)
self.assertEqual(d["a"], r.a)
self.assertEqual(d["c"], r.c)
with self.assertRaises(MogwaiException):
r.test = 0
with self.assertRaises(MogwaiException):
del r.test
# test iteration
self.assertEqual(len(d), len([v for v in r]))
self.assertListEqual(list(d.values()), [v for v in r])
# test next
self.assertIn(r.next(), d.values())
self.assertIn(r.next(), d.values())
self.assertIn(r.next(), d.values())
# test equality
r2 = Row(deepcopy(d))
self.assertEqual(r, r2)
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 send_metrics(self):
""" Default Hosted Graphite implementation is to dump all metrics to STDOUT
Change this if you want to customize for a particular metric collection system, ie. graphite, newrelic, etc.
"""
metrics = self.get_metrics()
if not metrics:
return
for mkey, metric in metrics.items():
for mname, mval in metric.items():
try:
self.agent.record_custom_metric(self.convert_metric_name(mkey, mname), mval, None)
except Exception as e:
print_(e)
def send_metrics(self):
""" Default Hosted Graphite implementation is to dump all metrics to STDOUT
Change this if you want to customize for a particular metric collection system, ie. graphite, newrelic, etc.
"""
metrics = self.get_metrics()
if metrics:
try:
request = urllib.Request(self.url, metrics)
request.add_header(
"Authorization", "Basic {}".format(
base64.encodestring(self.api_key).strip()))
result = urllib.urlopen(request)
except Exception as e:
print_(e)
def send_metrics(self):
""" Default Hosted Graphite implementation is to dump all metrics to STDOUT
Change this if you want to customize for a particular metric collection system, ie. graphite, newrelic, etc.
"""
metrics = self.get_metrics()
if not metrics:
return
for mkey, metric in metrics.items():
for mname, mval in metric.items():
try:
self.agent.record_custom_metric(
self.convert_metric_name(mkey, mname), mval, None)
except Exception as e:
print_(e)
def test_reload(self):
"""
Tests that the reload method performs an inplace update of an instance's values
"""
e1 = TestEdgeModel.create(self.v1, self.v2, test_val=3)
e2 = TestEdgeModel.get(e1.id)
print_('\n{} {} {}: {} {}'.format(e1.id, e2.id, e1 == e2, e1.test_val, e2.test_val))
e2.test_val = 5
e2.save()
print_("{} {} {}: {} {}".format(e1.id, e2.id, e1 == e2, e1.test_val, e2.test_val))
self.assertEqual(e1.test_val, 3)
e1.reload()
self.assertEqual(e1.test_val, 5)
e1 = self.v1.outE()[0]
self.assertEqual(e1.test_val, 5)
e2.delete()
def test_loaded(self):
spec = connection.generate_spec()
self.assertIsInstance(spec, (list, tuple))
self.assertGreater(len(spec), 0)
for s in spec:
print_(s)
self.assertIsInstance(s, dict)
self.assertDictContainsKeyWithValueType(s, 'model', string_types)
self.assertDictContainsKeyWithValueType(s, 'element_type', string_types)
self.assertDictContainsKeyWithValueType(s, 'makeType', string_types)
self.assertDictContainsKeyWithValueType(s, 'properties', dict)
for pk, pv in s['properties'].items():
self.assertDictContainsKeyWithValueType(pv, 'data_type', string_types)
self.assertDictContainsKeyWithValueType(pv, 'index_ext', string_types)
self.assertDictContainsKeyWithValueType(pv, 'uniqueness', string_types)
self.assertDictContainsKeyWithValueType(pv, 'compiled', dict)
self.assertDictContainsKeyWithValueType(pv['compiled'], 'script', string_types)
self.assertDictContainsKeyWithValueType(pv['compiled'], 'params', dict)
self.assertDictContainsKeyWithValueType(pv['compiled'], 'transaction', bool)
def test_reload(self):
"""
Tests that the reload method performs an inplace update of an instance's values
"""
e1 = TestEdgeModel.create(self.v1, self.v2, test_val=3)
e2 = TestEdgeModel.get(e1.id)
print_('\n{} {} {}: {} {}'.format(e1.id, e2.id, e1 == e2, e1.test_val,
e2.test_val))
e2.test_val = 5
e2.save()
print_("{} {} {}: {} {}".format(e1.id, e2.id, e1 == e2, e1.test_val,
e2.test_val))
self.assertEqual(e1.test_val, 3)
e1.reload()
self.assertEqual(e1.test_val, 5)
e1 = self.v1.outE()[0]
self.assertEqual(e1.test_val, 5)
e2.delete()
def test_parsing_complicated_function(self):
""" Groovy test parser functionality """
groovy_file_def = parse(self.groovy_file)
""" :type groovy_file_def: GroovyFileDef """
print_(groovy_file_def)
self.assertIsInstance(groovy_file_def, GroovyFileDef)
self.assertEqual(groovy_file_def.filename, self.groovy_file)
self.assertIsInstance(groovy_file_def.imports, (list, tuple))
self.assertIsInstance(groovy_file_def.functions, (list, tuple))
for import_def in groovy_file_def.imports:
if import_def is not None:
self.assertIsInstance(import_def, GroovyImport)
print_("Import: {}".format(import_def))
for func_def in groovy_file_def.functions:
if func_def is not None:
self.assertIsInstance(func_def, GroovyFunction)
print_("Function: {}".format(func_def))
groovy_funcs = groovy_file_def.functions
self.assertEqual(len(groovy_funcs[6].body.split('\n')), 8)
result_map = {x.name: x for x in groovy_funcs}
self.assertIn('get_self', result_map)
self.assertIn('return_value', result_map)
self.assertIn('long_func', result_map)
def test_good_choices_key_io(self):
print_("creating vertex")
dt = BooleanTestChoicesVertex.create(test_val=False)
print_("validating input")
self.assertEqual(dt.test_val, False)
print_("deleting vertex")
dt.delete()
def test_good_choices_key_io(self):
print_("creating vertex")
dt = DateTimeNaiveTestChoicesVertex.create(test_val=datetime.datetime(2014, 1, 1))
print_("validating input")
self.assertEqual(dt.test_val, datetime.datetime(2014, 1, 1))
print_("deleting vertex")
dt.delete()
def test_good_choices_value_io(self):
print_("creating vertex")
dt = StringTestChoicesVertex.create(test_val=1)
print_("validating input")
self.assertEqual(dt.test_val, 'A')
print_("deleting vertex")
dt.delete()
def test_relationship_isolation(self):
""" Test that the relationship adheres to instance methods """
v11 = self.vertex_model.create(name='test1')
e1, v12 = v11.relation.create(vertex_params={'name': 'new_relation_1'})
r11 = deepcopy(v11.relation.vertices())
print_("Vertex 1-1 relationships: {}".format(r11))
v21 = self.vertex_model.create(name='test2')
e2, v22 = v21.relation.create(vertex_params={'name': 'new_relation_2'})
r2 = deepcopy(v21.relation.vertices())
print_("Vertex 2-1 relationships: {}".format(r2))
with self.assertRaises(AssertionError):
self.assertListEqual(r11, r2)
r12 = deepcopy(v11.relation.vertices())
print_("Vertex 1-1 relationships again: {}".format(r12))
with self.assertRaises(AssertionError):
self.assertListEqual(r2, r12)
self.assertListEqual(r11, r12)
v11.delete()
v12.delete()
v21.delete()
v22.delete()
def test_relationship_isolation(self):
""" Test that the relationship adheres to instance methods """
v11 = self.vertex_model.create(name='test1')
e1, v12 = v11.relation.create(vertex_params={'name': 'new_relation_1'})
r11 = deepcopy(v11.relation.vertices())
print_("Vertex 1-1 relationships: {}".format(r11))
v21 = self.vertex_model.create(name='test2')
e2, v22 = v21.relation.create(vertex_params={'name': 'new_relation_2'})
r2 = deepcopy(v21.relation.vertices())
print_("Vertex 2-1 relationships: {}".format(r2))
with self.assertRaises(AssertionError):
self.assertListEqual(r11, r2)
r12 = deepcopy(v11.relation.vertices())
print_("Vertex 1-1 relationships again: {}".format(r12))
with self.assertRaises(AssertionError):
self.assertListEqual(r2, r12)
self.assertListEqual(r11, r12)
v11.delete()
v12.delete()
v21.delete()
v22.delete()
def test_bad_choices_io(self):
with self.assertRaises(ValidationError):
print_("creating vertex")
dt = StringTestChoicesVertex.create(test_val=3)
print_("validating input")
self.assertEqual(dt.test_val, 'C')
print_("deleting vertex")
dt.delete()
def test_bad_choices_io(self):
with self.assertRaises(ValidationError):
print_("creating vertex")
dt = BooleanTestChoicesVertex.create(test_val=None)
print_("validating input")
self.assertEqual(dt.test_val, None)
print_("deleting vertex")
dt.delete()
def test_bad_choices_io(self):
with self.assertRaises(ValidationError):
print_("creating vertex")
dt = DateTimeNaiveTestChoicesVertex.create(test_val=datetime.datetime(2014, 3, 1))
print_("validating input")
self.assertEqual(dt.test_val, 'C')
print_("deleting vertex")
dt.delete()
def test_good_choices_value_io(self):
# Known to be a bug, all keys and choices must be int | long | datetime
print_("creating vertex")
dt = DateTimeNaiveTestChoicesVertex.create(test_val='B')
print_("validating input")
self.assertEqual(dt.test_val, datetime.datetime(2014, 2, 1))
print_("deleting vertex")
dt.delete()
def test_find_by_value_method(self):
e1 = TestEdgeModel.create(self.v1, self.v2, test_val=-99, name='e1')
e2 = TestEdgeModel.create(self.v1, self.v2, test_val=-100, name='e2')
e3 = TestEdgeModelDouble.create(self.v1, self.v2, test_val=-101.0, name='e3')
self.assertEqual(len(TestEdgeModel.find_by_value('test_val', -99)), 1)
self.assertEqual(len(TestEdgeModel.find_by_value('test_val', -100)), 1)
self.assertEqual(len(TestEdgeModel.find_by_value('test_val', -102)), 0)
self.assertEqual(len(TestEdgeModel.find_by_value('name', 'e2')), 1)
self.assertEqual(len(TestEdgeModelDouble.find_by_value('test_val', -101.0)), 1)
print_(e1)
print_(e2)
print_(e3)
e1.delete()
e2.delete()
e3.delete()
def test_find_by_value_method(self):
e1 = TestEdgeModel.create(self.v1, self.v2, test_val=-99, name='e1')
e2 = TestEdgeModel.create(self.v1, self.v2, test_val=-100, name='e2')
e3 = TestEdgeModelDouble.create(self.v1,
self.v2,
test_val=-101.0,
name='e3')
self.assertEqual(len(TestEdgeModel.find_by_value('test_val', -99)), 1)
self.assertEqual(len(TestEdgeModel.find_by_value('test_val', -100)), 1)
self.assertEqual(len(TestEdgeModel.find_by_value('test_val', -102)), 0)
self.assertEqual(len(TestEdgeModel.find_by_value('name', 'e2')), 1)
self.assertEqual(
len(TestEdgeModelDouble.find_by_value('test_val', -101.0)), 1)
print_(e1)
print_(e2)
print_(e3)
e1.delete()
e2.delete()
e3.delete()
def test_positive_integer_io(self):
print_("creating vertex")
dt = PositiveIntegerTestVertex.create(test_val=1)
print_("getting vertex from vertex: %s" % dt)
dt2 = PositiveIntegerTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = PositiveIntegerTestVertex.create(test_val=2)
print_("\ncreated vertex: %s" % dt)
dt2 = PositiveIntegerTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 2)
print_("deleting vertex")
dt2.delete()
def test_slug_io(self):
print_("creating vertex")
dt = SlugTestVertex.create(test_val='ab12')
print_("getting vertex from vertex: %s" % dt)
dt2 = SlugTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = SlugTestVertex.create(test_val='12ab')
print_("\ncreated vertex: %s" % dt)
dt2 = SlugTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, '12ab')
print_("deleting vertex")
dt2.delete()
from mogwai.connection import setup
from mogwai._compat import print_
from diya.models import DataFactory, Relation
setup('192.168.1.107')
dharni = DataFactory.create('person', key="dharni", name="dharni", age="20")
vijay = DataFactory.create('person', key="vijay", name="vijay", age="20")
friend = Relation.create(outV=dharni, inV=vijay, name='friends')
employee = Relation.create(outV=dharni, inV=vijay, name='coworker')
edges = Relation.get_between(outV=dharni, inV=vijay)
print_(edges)
for e in edges:
edge = e
print_(edge)
print_(edge.keys())
print_(edge.values())
def test_ipv6_io(self):
print_("creating vertex")
dt = IPV6TestVertex.create(test_val='1::8')
print_("getting vertex from vertex: %s" % dt)
dt2 = IPV6TestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = IPV6TestVertex.create(test_val='1::7:8')
print_("\ncreated vertex: %s" % dt)
dt2 = IPV6TestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, '1::7:8')
print_("deleting vertex")
dt2.delete()
bob = Person.create(name="Bob", email="*****@*****.**")
alice = Person.create(name="Alice", email="*****@*****.**")
john = Person.create(name="John", email="*****@*****.**")
tim = Person.create(name="Tim", email="*****@*****.**")
kyle = Person.create(name="Kyle", email="*****@*****.**")
# Create Friendships
IsFriendsWith.create(outV=bob, inV=alice)
IsFriendsWith.create(outV=alice, inV=john)
IsFriendsWith.create(outV=alice, inV=tim)
IsFriendsWith.create(outV=tim, inV=kyle)
## Traverse
# All known direct friends with Bob
bobs_friends = bob.friends
print_("Bobs direct friends: {}".format(bobs_friends))
# Output:
# [ Person(element_type=person, id=8132, values={'name': Alice, 'email': [email protected]}) ]
# Friends and Friends of Friends using Custom Gremlin Method
bobs_friends_and_friends_of_friends = bob.friends_and_friends_of_friends
print_("Bobs Friends and Friends of Friends: {}".format(bobs_friends_and_friends_of_friends))
# Output:
# [
# [ Person(element_type=person, id=8128, values={'name': Bob, 'email': [email protected]}),
# Person(element_type=person, id=8132, values={'name': Alice, 'email': [email protected]}),
# Person(element_type=person, id=8136, values={'name': John, 'email': [email protected]})
# ], [
# Person(element_type=person, id=8128, values={'name': Bob, 'email': [email protected]}),
def test_email_io(self):
print_("creating vertex")
dt = EmailTestVertex.create(test_val="*****@*****.**")
print_("getting vertex from vertex: %s" % dt)
dt2 = EmailTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = EmailTestVertex.create(test_val="*****@*****.**")
print_("\ncreated vertex: %s" % dt)
dt2 = EmailTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, "*****@*****.**")
print_("deleting vertex")
dt2.delete()
from functools import partial
from mogwai._compat import print_
import xlrd
import simplejson as json
setup('192.168.0.140')
class Data(Vertex):
element_type = "data"
wb = xlrd.open_workbook('/Users/dharni/Downloads/WA_Energy_Weather_Use_Case_Datasets/EU_EnergyPocketbook2014_Exploration_Layout.xls')
sh = wb.sheet_by_index(0)
values = []
for row_index in xrange(1, sh.nrows):
for col_index in xrange(sh.ncols):
values.insert(col_index, sh.cell(row_index, col_index).value)
#Data.create(col_1=values[0],col_2=values[1],col_3=values[2],col_4=values[3],col_5=values[4],col_6=values[5],col_7=values[6])
results = Data.find_by_value("col_5","Belgium",False)
print_(type(results))
print_(len(results))
for v in results:
data = Data()
data = v
print_(data.id)
print_(data.values())
def test_uuid1_io(self):
print_("creating vertex")
dt = UUID1TestVertex.create(
test_val='bb19eaed-c946-4cef-8001-7cc3357cc439')
print_("getting vertex from vertex: %s" % dt)
dt2 = UUID1TestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = UUID1TestVertex.create(
test_val='bb19eaed-c946-4cef-8001-7cc3357cc439')
print_("\ncreated vertex: %s" % dt)
dt2 = UUID1TestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 'bb19eaed-c946-4cef-8001-7cc3357cc439')
print_("deleting vertex")
dt2.delete()
def test_url_io(self):
print_("creating vertex")
dt = URLTestVertex.create(test_val='http://wellaware.us')
print_("getting vertex from vertex: %s" % dt)
dt2 = URLTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = URLTestVertex.create(test_val='http://www.wellaware.us/')
print_("\ncreated vertex: %s" % dt)
dt2 = URLTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 'http://www.wellaware.us/')
print_("deleting vertex")
dt2.delete()
def test_dictionary_io(self):
print_("creating vertex")
dt = DictionaryTestVertex.create(test_val={'test': 1})
print_("getting vertex from vertex: %s" % dt)
dt2 = DictionaryTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = DictionaryTestVertex.create(test_val={'test2': 2})
print_("\ncreated vertex: %s" % dt)
dt2 = DictionaryTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, {'test2': 2})
print_("deleting vertex")
dt2.delete()
def test_boolean_io(self):
print_("creating vertex")
dt = BooleanTestVertex.create(test_val=True)
print_("getting vertex from vertex: %s" % dt)
dt2 = BooleanTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = BooleanTestVertex.create(test_val=True)
print_("\ncreated vertex: %s" % dt)
dt2 = BooleanTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, True)
print_("deleting vertex")
dt2.delete()
def test_uuid1_io(self):
print_("creating vertex")
dt = UUID1TestVertex.create(test_val='bb19eaed-c946-4cef-8001-7cc3357cc439')
print_("getting vertex from vertex: %s" % dt)
dt2 = UUID1TestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = UUID1TestVertex.create(test_val='bb19eaed-c946-4cef-8001-7cc3357cc439')
print_("\ncreated vertex: %s" % dt)
dt2 = UUID1TestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 'bb19eaed-c946-4cef-8001-7cc3357cc439')
print_("deleting vertex")
dt2.delete()
def test_good_validation(self):
for case in self.good_cases:
print_("testing case: {}".format(case))
self.assertNotRaise(self.klass, case)
def test_bad_validation(self):
for case in self.bad_cases:
print_("testing case: {}".format(case))
self.assertRaises(ValidationError, self.klass, case)
def test_short_io(self):
print_("creating vertex")
dt = ShortTestVertex.create(test_val=1)
print_("getting vertex from vertex: %s" % dt)
dt2 = ShortTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = ShortTestVertex.create(test_val=2)
print_("\ncreated vertex: %s" % dt)
dt2 = ShortTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 2)
print_("deleting vertex")
dt2.delete()
def test_datetime_naive_io(self):
print_("creating vertex")
dt = DateTimeNaiveTestVertex.create(test_val=datetime.datetime(2014, 1, 1))
print_("getting vertex from vertex: %s" % dt)
dt2 = DateTimeNaiveTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = DateTimeNaiveTestVertex.create(test_val=datetime.datetime(2014, 1, 1))
print_("\ncreated vertex: %s" % dt)
dt2 = DateTimeNaiveTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, datetime.datetime(2014, 1, 1))
print_("deleting vertex")
dt2.delete()
def test_ipv4_io(self):
print_("creating vertex")
dt = IPV4TestVertex.create(test_val='1.2.3.4')
print_("getting vertex from vertex: %s" % dt)
dt2 = IPV4TestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = IPV4TestVertex.create(test_val='4.3.2.1')
print_("\ncreated vertex: %s" % dt)
dt2 = IPV4TestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, '4.3.2.1')
print_("deleting vertex")
dt2.delete()
def test_positive_integer_io(self):
print_("creating vertex")
dt = PositiveIntegerTestVertex.create(test_val=1)
print_("getting vertex from vertex: %s" % dt)
dt2 = PositiveIntegerTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = PositiveIntegerTestVertex.create(test_val=2)
print_("\ncreated vertex: %s" % dt)
dt2 = PositiveIntegerTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 2)
print_("deleting vertex")
dt2.delete()
# Define a shortcut relationship method
belongings = relationships.Relationship(OwnsObject, Trinket)
## Creation
# Create a trinket
trinket = Trinket.create(name='Clock')
# Create a Person
bob = Person.create(name='Bob Smith', email='*****@*****.**')
# Create the Ownership Relationship
relationship = OwnsObject.create(outV=bob, inV=trinket)
## Traversals
# Find out what bob owns
bob_owns_relationships = bob.belongings.vertices()
bob_owns_vertex_traversal = bob.outV(OwnsObject)
print_("With Relationships: Bob owns: {}".format(bob_owns_relationships))
# Another method for the same thing
print_("With Vertex Traversal: Bob owns: {}".format(bob_owns_vertex_traversal))
assert bob_owns_relationships == bob_owns_vertex_traversal
# Find out who owns the trinket
print_("With Vertex Traversal: Trinket is owned by: {}".format(
trinket.inV(OwnsObject)))
# When was the trinket owned?
print_("Trinket has been owned since: {}".format(relationship.since))
def test_short_io(self):
print_("creating vertex")
dt = ShortTestVertex.create(test_val=1)
print_("getting vertex from vertex: %s" % dt)
dt2 = ShortTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = ShortTestVertex.create(test_val=2)
print_("\ncreated vertex: %s" % dt)
dt2 = ShortTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 2)
print_("deleting vertex")
dt2.delete()
def test_dictionary_io(self):
print_("creating vertex")
dt = DictionaryTestVertex.create(test_val={'test': 1})
print_("getting vertex from vertex: %s" % dt)
dt2 = DictionaryTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = DictionaryTestVertex.create(test_val={'test2': 2})
print_("\ncreated vertex: %s" % dt)
dt2 = DictionaryTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, {'test2': 2})
print_("deleting vertex")
dt2.delete()
def test_slug_io(self):
print_("creating vertex")
dt = SlugTestVertex.create(test_val="ab12")
print_("getting vertex from vertex: %s" % dt)
dt2 = SlugTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = SlugTestVertex.create(test_val="12ab")
print_("\ncreated vertex: %s" % dt)
dt2 = SlugTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, "12ab")
print_("deleting vertex")
dt2.delete()
def test_input_output_equality(self):
d = datetime.datetime(2014, 1, 1, tzinfo=utc)
prop = self.klass()
result = prop.to_python(prop.to_database(d))
print_("Input: %s, Output: %s" % (d, result))
self.assertEqual(d, result)
def test_list_io(self):
print_("creating vertex")
dt = ListTestVertex.create(test_val=['a', 'b'])
print_("getting vertex from vertex: %s" % dt)
dt2 = ListTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = ListTestVertex.create(test_val=[1, 2])
print_("\ncreated vertex: %s" % dt)
dt2 = ListTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, [1, 2])
print_("deleting vertex")
dt2.delete()
def test_url_io(self):
print_("creating vertex")
dt = URLTestVertex.create(test_val='http://wellaware.us')
print_("getting vertex from vertex: %s" % dt)
dt2 = URLTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = URLTestVertex.create(test_val='http://www.wellaware.us/')
print_("\ncreated vertex: %s" % dt)
dt2 = URLTestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, 'http://www.wellaware.us/')
print_("deleting vertex")
dt2.delete()
def test_ipv64_io(self):
print_("creating vertex")
dt = IPV64TestVertex.create(test_val='::255.255.255.255')
print_("getting vertex from vertex: %s" % dt)
dt2 = IPV64TestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = IPV64TestVertex.create(test_val='::ffff:255.255.255.255')
print_("\ncreated vertex: %s" % dt)
dt2 = IPV64TestVertex.get(dt._id)
print_("Got vertex: %s" % dt2)
self.assertEqual(dt2.test_val, '::ffff:255.255.255.255')
print_("deleting vertex")
dt2.delete()
# Define a shortcut relationship method
belongings = relationships.Relationship(OwnsObject, Trinket)
## Creation
# Create a trinket
trinket = Trinket.create(name='Clock')
# Create a Person
bob = Person.create(name='Bob Smith', email='*****@*****.**')
# Create the Ownership Relationship
relationship = OwnsObject.create(outV=bob, inV=trinket)
bob_serialized = pickle.dumps(bob)
print_("Bob Serialized: {}".format(bob_serialized))
deserialized_bob = pickle.loads(bob_serialized)
print_("Bob Deserialized: {}".format(deserialized_bob))
assert bob == bob_serialized
relationship_serialized = pickle.dumps(relationship)
print_("Relationship Serialized: {}".format(relationship_serialized))
deserialized_relationship = pickle.loads(relationship_serialized)
print_("Relationship Deserialized: {}".format(deserialized_relationship))
assert relationship == relationship_serialized
trinket_serialized = pickle.dumps(trinket)
print_("Trinket Serialized: {}".format(trinket_serialized))
deserialized_trinket = pickle.loads(trinket_serialized)
print_("Trinket Deserialized: {}".format(deserialized_trinket))
assert trinket == trinket_serialized
def test_decimal_io(self):
print_("creating vertex")
dt = DecimalTestVertex.create(test_val=_D('1.00'))
print_("getting vertex from vertex: %s" % dt)
dt2 = DecimalTestVertex.get(dt._id)
print_("got vertex: %s\n" % dt2)
self.assertEqual(dt2.test_val, dt.test_val)
print_("deleting vertex")
dt2.delete()
dt = DecimalTestVertex.create(test_val=5)
print_("\ncreated vertex: %s" % dt)
dt2 = DecimalTestVertex.get(dt._id)
print_("Got decimal vertex: %s" % dt2)
self.assertEqual(dt2.test_val, _D('5'))
print_("deleting vertex")
dt2.delete()
