File: test_datetime_range.py

package info (click to toggle)
python-sqlalchemy-utils 0.30.12-2~bpo8%2B1
  • links: PTS, VCS
  • area: main
  • in suites: jessie-backports
  • size: 1,056 kB
  • sloc: python: 10,350; makefile: 160
file content (100 lines) | stat: -rw-r--r-- 2,821 bytes parent folder | download | duplicates (2)
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
from datetime import datetime, timedelta

import sqlalchemy as sa
from pytest import mark

from sqlalchemy_utils import DateTimeRangeType
from tests import TestCase

intervals = None
inf = 0
try:
    import intervals
    from infinity import inf
except ImportError:
    pass


@mark.skipif('intervals is None')
class DateRangeTestCase(TestCase):
    def create_models(self):
        class Booking(self.Base):
            __tablename__ = 'booking'
            id = sa.Column(sa.Integer, primary_key=True)
            during = sa.Column(DateTimeRangeType)

        self.Booking = Booking

    def create_booking(self, date_range):
        booking = self.Booking(
            during=date_range
        )

        self.session.add(booking)
        self.session.commit()
        return self.session.query(self.Booking).first()

    def test_nullify_range(self):
        booking = self.create_booking(None)
        assert booking.during is None

    @mark.parametrize(
        ('date_range'),
        (
            [datetime(2015, 1, 1), datetime(2015, 1, 3)],
            [datetime(2015, 1, 1), inf],
            [-inf, datetime(2015, 1, 1)]
        )
    )
    def test_save_date_range(self, date_range):
        booking = self.create_booking(date_range)
        assert booking.during.lower == date_range[0]
        assert booking.during.upper == date_range[1]

    def test_nullify_date_range(self):
        booking = self.Booking(
            during=intervals.DateInterval(
                [datetime(2015, 1, 1), datetime(2015, 1, 3)]
            )
        )

        self.session.add(booking)
        self.session.commit()

        booking = self.session.query(self.Booking).first()
        booking.during = None
        self.session.commit()

        booking = self.session.query(self.Booking).first()
        assert booking.during is None

    def test_integer_coercion(self):
        booking = self.Booking(during=datetime(2015, 1, 1))
        assert booking.during.lower == datetime(2015, 1, 1)
        assert booking.during.upper == datetime(2015, 1, 1)


class TestDateRangeOnPostgres(DateRangeTestCase):
    dns = 'postgres://postgres@localhost/sqlalchemy_utils_test'

    @mark.parametrize(
        ('date_range', 'length'),
        (
            (
                [datetime(2015, 1, 1), datetime(2015, 1, 3)],
                timedelta(days=2)
            ),
            (
                [datetime(2015, 1, 1), datetime(2015, 1, 1)],
                timedelta(days=0)
            ),
            ([-inf, datetime(2015, 1, 1)], None),
            ([datetime(2015, 1, 1), inf], None),
        )
    )
    def test_length(self, date_range, length):
        self.create_booking(date_range)
        query = (
            self.session.query(self.Booking.during.length)
        )
        assert query.scalar() == length