def test_can_ensure_that_a_value_the_same_as_a_previously_bound_param_returns_previous_params_value( self): n = 'some_name' v = 'value {}'.format(random()) p = Pypher() param = p.bind_param(v, n) param2 = p.bind_param(n) str(p) params = p.bound_params self.assertEqual(1, len(params)) self.assertEqual(param.name, param2.name)
def test_can_use_subclassed_function_by_classname(self): class SubClassedFunc(Func): name = 'sub_class_func' p = Pypher() y = 12 p.SubClassedFunc(y) x = str(p) params = p.bound_params expected = 'sub_class_func(${})'.format(get_dict_key(params, y)) self.assertEqual(x, expected) self.assertEqual(1, len(params))
def test_can_use_subclassed_statement_by_classname(self): class SubClassedStatement(Statement): name = 'sub_class_stmt' p = Pypher() y = 12 p.SubClassedStatement(y) x = str(p) params = p.bound_params expected = 'sub_class_stmt {}'.format(y) self.assertEqual(x, expected) self.assertEqual(0, len(params))
def get_show_all_nodes_query(node_type=None): """ :param node_type: type of nodes to show. :return: the query to show all nodes. Optional: Type of nodes to be recognized. """ # should be bundle, copilationUnit or package. Could be extracted via tracker.slots.get('nodeType'). pypher_object = Pypher() if node_type is None: pypher_object.Match.node('u') else: pypher_object.Match.node('u', labels=node_type) pypher_object.RETURN('u') return GenerateQuery.reformat_query(pypher_object)
def test_can_nest_AND_and_OR_conditionals(self): p = Pypher() p.COR(1, __.CAND(2, 3)) s = str(p) params = p.bound_params exp = '(${one} OR (${two} AND ${three}))'.format( one=get_dict_key(params, 1), two=get_dict_key(params, 2), three=get_dict_key(params, 3)) self.assertEqual(exp, s) self.assertEqual(3, len(params))
def test_can_use_base_conditional(self): p = Pypher() p.CONDITIONAL(1, 2, 3) s = str(p) params = p.bound_params exp = '(${one}, ${two}, ${three})'.format(one=get_dict_key(params, 1), two=get_dict_key(params, 2), three=get_dict_key( params, 3)) self.assertEqual(exp, s) self.assertEqual(3, len(params))
def _build_start(): pypher = Pypher() if self.start_entity.id is not None: qv = self.start_entity.query_variable where = __.ID(qv) == self.start_entity.id pypher.NODE(qv) self.wheres.append(where) else: pypher.NODE(self.start_query_variable) return pypher
def _build_end(self): pypher = Pypher() qv = self.end_query_variable labels = None if self.end_entity: qv = self.end_entity.query_variable labels = self.end_entity.labels pypher.NODE(qv, labels=labels) self.returns.append(qv) return pypher
def test_can_add_random_function_with_args(self): p = Pypher() f = 'someFunction{}'.format(random()) one = 'one' two = 2 p.func(f, one, two) c = str(p) params = p.bound_params exp = '{}(${}, ${})'.format(f, get_dict_key(params, one), get_dict_key(params, two)) self.assertEqual(c, exp) self.assertEqual(2, len(params))
def test_can_use_subclassed_function_by_alias(self): class SubClassedFunc2(Func): name = 'sub_class_func2' _ALIASES = ['scf'] p = Pypher() y = 12 p.scf(y) x = str(p) params = p.bound_params expected = 'sub_class_func2(${})'.format(get_dict_key(params, y)) self.assertEqual(x, expected) self.assertEqual(1, len(params))
def _build_start(self): pypher = Pypher() if self.start_entity.id: qv = self.start_entity.query_variable where = __.ID(qv) == self.start_entity.id pypher.NODE(qv) self.wheres.append(where) else: pypher.NODE(self.start_query_variable, labels=self.start_entity.labels) return pypher
def test_can_use_subclassed_statement_by_alias_and_classname(self): class SubClassedStmt3(Statement): name = 'sub_class_stmt3' _ALIASES = ['scs3'] p = Pypher() y = 12 p.scs3(y).SubClassedStmt3(y) x = str(p) params = p.bound_params expected = 'sub_class_stmt3 {} sub_class_stmt3 {}'.format(y, y) self.assertEqual(x, expected) self.assertEqual(0, len(params))
def test_can_append_two_instances_first_is_empty(self): p = Pypher() p2 = Pypher() p2.two p.append(p2) exp = 'two' exp2 = 'two' s = str(p) s2 = str(p2) self.assertEqual(exp, s) self.assertEqual(exp2, s2)
def test_can_clone_nested_pypher(self): p = Pypher() d = Pypher() e = Pypher() e.CAND(1, 2, 3, 4, 5, __.test.this.out.CONDITIONAL(9, 9, 8, __.node(6))) d.id(123).raw(e) p.a.b.c.d.node(d == 122) c = p.clone() x = str(p) y = str(c) self.assertEqual(x, y) self.assertEqual(len(p.bound_params), len(c.bound_params)) self.assertTrue(id(p.bound_params) == id(c.bound_params))
def test_can_add_named_node_labeled_out_relationship_node_with_properties(self): n = 'name' l = 'KNOWS' name = 'somename' age = 99 p = Pypher() p.node(n).rel_out(labels=l).node(name=name, age=age) c = str(p) params = p.bound_params exp = '({n})-[:`{l}`]->( {{`age`: ${age}, `name`: ${name}}})'.format(n=n, l=l, name=get_dict_key(params, name), age=get_dict_key(params, age)) self.assertEqual(c, exp) self.assertEqual(2, len(params))
def test_can_bind_multiple_ununique_primitives_to_pypher(self): v = 'value {}'.format(random()) v2 = v p = Pypher() par = p.bind_param(v) par2 = p.bind_param(v2) str(p) params = p.bound_params self.assertIn(v, params.values()) self.assertIn(v2, params.values()) self.assertEqual(1, len(params)) self.assertEqual(par.name, par2.name)
def test_can_bind_param_object_to_pypher(self): n = 'some name' v = 'value {}'.format(random()) v = Param(n, v) p = Pypher() param = p.bind_param(v) str(p) params = p.bound_params self.assertNotEqual(id(v), id(param)) self.assertIn(v.value, params.values()) self.assertIn(n, params) self.assertEqual(1, len(params))
def get_node_information_query(node_name, node_type=None): """ :param node_name: name of the node to get information about. :return: the query for showing general information of one node (any entity) with a specific name. """ pypher_object = Pypher() if node_type is None: pypher_object.Match.node('u').where.u.__name__.CONTAINS( Param('per_param', node_name)) else: pypher_object.Match.node( 'u', labels=node_type).where.u.__name__.CONTAINS( Param('per_param', node_name)) pypher_object.RETURN('u') return GenerateQuery.reformat_query(pypher_object)
def test_can_append_two_instances(self): p = Pypher() p2 = Pypher() p.one p2.two p.append(p2) exp = 'one two' exp2 = 'two' s = str(p) s2 = str(p2) self.assertEqual(exp, s) self.assertEqual(exp2, s2)
def test_can_add_named_undirected_relationship_with_labels_and_properties( self): p = Pypher() name = 'somename' age = 99 p.relationship(variable='test', labels=['one', 'two', 'three'], name=name, age=age) c = str(p) params = p.bound_params exp = '-[test:`one`|`two`|`three` {{`age`: ${a}, `name`: ${n}}}]-'.format( n=get_dict_key(params, name), a=get_dict_key(params, age)) self.assertEqual(str(p), exp)
def test_can_add_list(self): p = Pypher() one = 1 two = 2 three = 3 p.List(one, two, three) c = str(p) params = p.bound_params exp = '[${one}, ${two}, ${three}]'.format( one=get_dict_key(params, one), two=get_dict_key(params, two), three=get_dict_key(params, three)) self.assertEqual(exp, c) self.assertEqual(3, len(params))
def delete_by_entity_id(self, *ids): if not ids: msg = 'There must be ids passed in to the delete method' raise AttributeError(msg) def _build_start(): pypher = Pypher() if self.start_entity.id is not None: qv = self.start_entity.query_variable where = __.ID(qv) == self.start_entity.id pypher.NODE(qv) self.wheres.append(where) else: pypher.NODE(self.start_query_variable) return pypher self.pypher = Pypher() self.matches.insert(0, self._build_end()) self.matches.insert(0, self._build_relationship()) self.matches.insert(0, _build_start()) self.pypher.MATCH for match in self.matches: self.pypher.append(match) id_params = [] for i in ids: key = 'end_id_{}'.format(i) id_params.append(Param(key, i)) self.wheres.append(__.ID(self.end_query_variable).IN(*id_params)) _id = __.ID(self.start_query_variable) if self.start_entity.id is not None: self.wheres.append(_id == self.start_entity.id) # else: # wheres.append(_id) self.pypher.WHERE.CAND(*self.wheres) self.pypher.DELETE(self.relationship_query_variable) self.reset() return str(self.pypher), self.pypher.bound_params
def test_can_add_single_label(self): p = Pypher() p.n.label('one') exp = 'n:`one`' self.assertEqual(str(p), exp)
def test_can_add_raw(self): p = Pypher() s = 'raw content {}'.format(random()) p.this.will.be.raw(s) exp = 'this will be {}'.format(s) self.assertEqual(str(p), exp)
def test_can_use_nested_dictionary_in_operator(self): lat = random() lng = random() d = { 'name': 'name_{}'.format(str(random())), 'loc': { 'city': 'city_{}'.format(str(random())), 'latlng': [lat, lng], }, } p = Pypher() p.SET.user += d q = str(p) params = p.bound_params exp = ( 'SET user += {{`loc`: {{`city`: ${city}, `latlng`: [${lat}, ${lng}]}}, `name`: ${name}}}' ).format(name=get_dict_key(params, d['name']), city=get_dict_key(params, d['loc']['city']), lat=get_dict_key(params, lat), lng=get_dict_key(params, lng)) self.assertEqual(exp, q) self.assertEqual(4, len(params)) self.assertIn(d['name'], params.values()) self.assertIn(d['loc']['city'], params.values())
def test_can_add_two_statements(self): p = Pypher() p.some_statement.some_other_statement expected = 'some_statement some_other_statement' c = str(p) self.assertEqual(c, expected)
def test_can_add_one_statement(self): p = Pypher() p.some_attribute expected = 'some_attribute' c = str(p) self.assertEqual(c, expected)
def test_can_add_two_properties_underscore(self): p = Pypher() p.__prop1__.__prop2__ expected = '.`prop1`.`prop2`' c = str(p) self.assertEqual(c, expected)
def test_can_bind_nonunique_mixed_primitive_and_param_object_to_pypher(self): n = 'some name' v = 'value {}'.format(random()) v2 = v v = Param(n, v) p = Pypher() param = p.bind_param(v) param2 = p.bind_param(v2) str(p) params = p.bound_params self.assertNotEqual(id(v), id(param)) self.assertIn(v.value, params.values()) self.assertIn(n, params) self.assertEqual(1, len(params)) self.assertEqual(param.name, param2.name)
def test_can_add_one_property_underscore(self): p = Pypher() p.__property__ expected = '.`property`' c = str(p) self.assertEqual(c, expected)