1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
# Copyright 2015 Hewlett-Packard Development Company, L.P.
#
# Author: Endre Karlson <endre.karlson@hpe.com>
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import operator
from unittest import mock
import sqlalchemy as sa
from sqlalchemy.sql import operators
from designate.sqlalchemy import base
from designate.tests import TestCase
metadata = sa.MetaData()
dummy_table = sa.Table('dummy', metadata,
sa.Column('id', sa.String(36)),
sa.Column('a', sa.String()),
sa.Column('int', sa.Integer()),
)
class SQLAlchemyTestCase(TestCase):
def setUp(self):
super(SQLAlchemyTestCase, self).setUp()
self.query = mock.Mock()
def test_wildcard(self):
criterion = {"a": "%foo%"}
op = dummy_table.c.a.like("%foo")
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operators.like_op, "%foo%", escape=None)
self.query.where.assert_called_with(op)
def test_ne(self):
criterion = {"a": "!foo"}
op = dummy_table.c.a != "foo"
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operator.ne, "foo")
self.query.where.assert_called_with(op)
def test_le(self):
criterion = {"a": "<=foo"}
op = dummy_table.c.a <= "foo"
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operator.le, "foo")
self.query.where.assert_called_with(op)
def test_lt(self):
criterion = {"a": "<foo"}
op = dummy_table.c.a < "foo"
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operator.lt, "foo")
self.query.where.assert_called_with(op)
def test_ge(self):
criterion = {"a": ">=foo"}
op = dummy_table.c.a >= "foo"
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operator.ge, "foo")
self.query.where.assert_called_with(op)
def test_gt(self):
criterion = {"a": ">foo"}
op = dummy_table.c.a > "foo"
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operator.gt, "foo")
self.query.where.assert_called_with(op)
def test_between(self):
criterion = {"a": "BETWEEN 1,3"}
op = dummy_table.c.a.between(1, 3)
with mock.patch.object(dummy_table.c.a, 'operate') as func:
func.return_value = op
base.SQLAlchemy._apply_criterion(
dummy_table, self.query, criterion)
func.assert_called_with(operators.between_op, '1', '3',
symmetric=False)
self.query.where.assert_called_with(op)
|
