def test___ne__(): parameter1 = query.Parameter("yep") parameter2 = query.Parameter("nope") parameter3 = unittest.mock.sentinel.parameter assert not parameter1 != parameter1 assert parameter1 != parameter2 assert parameter1 != parameter3
def test___eq__(): prop1 = model.Property(name="val") param1 = query.Parameter("abc") parameter_node1 = query.ParameterNode(prop1, "=", param1) prop2 = model.Property(name="ue") parameter_node2 = query.ParameterNode(prop2, "=", param1) parameter_node3 = query.ParameterNode(prop1, "<", param1) param2 = query.Parameter(900) parameter_node4 = query.ParameterNode(prop1, "=", param2) parameter_node5 = unittest.mock.sentinel.parameter_node assert parameter_node1 == parameter_node1 assert not parameter_node1 == parameter_node2 assert not parameter_node1 == parameter_node3 assert not parameter_node1 == parameter_node4 assert not parameter_node1 == parameter_node5
def test___repr__(): prop = model.Property(name="val") param = query.Parameter("abc") parameter_node = query.ParameterNode(prop, "=", param) expected = "ParameterNode({!r}, '=', Parameter('abc'))".format(prop) assert repr(parameter_node) == expected
def test_resolve_missing_key(): parameter = query.Parameter(9000) used = {} with pytest.raises(_exceptions.BadArgumentError): parameter.resolve({}, used) assert used == {}
def test_constructor(): prop = model.Property(name="val") param = query.Parameter("abc") parameter_node = query.ParameterNode(prop, "=", param) assert parameter_node._prop is prop assert parameter_node._op == "=" assert parameter_node._param is param
def _args_to_val(self, func, args): """Helper for GQL parsing to extract values from GQL expressions. This can extract the value from a GQL literal, return a Parameter for a GQL bound parameter (:1 or :foo), and interprets casts like KEY(...) and plain lists of values like (1, 2, 3). Args: func (str): A string indicating what kind of thing this is. args list[Union[int, str, Literal]]: One or more GQL values, each integer, string, or GQL literal. """ vals = [] for arg in args: if isinstance(arg, six.string_types + six.integer_types): val = query_module.Parameter(arg) else: val = arg.Get() vals.append(val) if func == "nop": return vals[0] # May be a Parameter pfunc = query_module.ParameterizedFunction(func, vals) if pfunc.is_parameterized(): return pfunc return pfunc.resolve({}, {})
def test_resolve(): key = 9000 bound_value = "resoolt" parameter = query.Parameter(key) used = {} result = parameter.resolve({key: bound_value}, used) assert result == bound_value assert used == {key: True}
def test_pickling(): prop = model.Property(name="val") param = query.Parameter("abc") parameter_node = query.ParameterNode(prop, "=", param) pickled = pickle.dumps(parameter_node) unpickled = pickle.loads(pickled) assert parameter_node == unpickled
def test_resolve(): prop = model.Property(name="val") param = query.Parameter("abc") parameter_node = query.ParameterNode(prop, "=", param) used = {} with pytest.raises(NotImplementedError): parameter_node.resolve({}, used) assert used == {}
def test_resolve_in_empty_container(): prop = model.Property(name="val") param = query.Parameter("replace") parameter_node = query.ParameterNode(prop, "in", param) value = () bindings = {"replace": value} used = {} resolved_node = parameter_node.resolve(bindings, used) assert resolved_node == query.FalseNode() assert used == {"replace": True}
def test_resolve_simple(): prop = model.Property(name="val") param = query.Parameter("abc") parameter_node = query.ParameterNode(prop, "=", param) value = 67 bindings = {"abc": value} used = {} resolved_node = parameter_node.resolve(bindings, used) assert resolved_node == query.FilterNode("val", "=", value) assert used == {"abc": True}
def test_resolve_with_in(): prop = model.Property(name="val") param = query.Parameter("replace") parameter_node = query.ParameterNode(prop, "in", param) value = (19, 20, 28) bindings = {"replace": value} used = {} resolved_node = parameter_node.resolve(bindings, used) assert resolved_node == query.DisjunctionNode( query.FilterNode("val", "=", 19), query.FilterNode("val", "=", 20), query.FilterNode("val", "=", 28), ) assert used == {"replace": True}
def test__to_filter(): prop = model.Property(name="val") param = query.Parameter("abc") parameter_node = query.ParameterNode(prop, "=", param) with pytest.raises(exceptions.BadArgumentError): parameter_node._to_filter()
def test_key(): parameter = query.Parameter(9000) assert parameter.key == 9000
def test_constructor_bad_property(): param = query.Parameter(11) with pytest.raises(TypeError): query.ParameterNode(None, "!=", param)
def test___repr__(): parameter = query.Parameter("ghi") assert repr(parameter) == "Parameter('ghi')"
def test_constructor_invalid(): with pytest.raises(TypeError): query.Parameter(None)
def test_constructor(): for key in (88, b"abc", "def"): parameter = query.Parameter(key) assert parameter._key == key
def test_constructor_bad_op(): prop = model.Property(name="guitar") param = query.Parameter("pick") with pytest.raises(TypeError): query.ParameterNode(prop, "less", param)