designate/designate/tests/test_sqlalchemy.py

# 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.storage.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().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)

    def test_regular_string(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(operator.eq, 'foo')
            self.query.where.assert_called_with(op)

    def test_list(self):
        criterion = {'a': ['foo']}

        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.in_op, ['foo'])
            self.query.where.assert_called_with(op)

    def test_boolean(self):
        criterion = {'a': True}

        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(operator.eq, True)
            self.query.where.assert_called_with(op)