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 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_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_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()
# 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_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_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()