datatracker/timedelta/tests.py at 71cfe9459fcd1edc89ad972a275804301cdcaa61 · https-github-com-bit/datatracker · GitHub

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
123
124
125
126
127
128
from unittest import TestCase
import datetime
import doctest

from django.core.exceptions import ValidationError
from django.db import models
from django.utils import six

from .fields import TimedeltaField
import timedelta.helpers
import timedelta.forms
import timedelta.widgets

class MinMaxTestModel(models.Model):
    min = TimedeltaField(min_value=datetime.timedelta(1))
    max = TimedeltaField(max_value=datetime.timedelta(1))
    minmax = TimedeltaField(min_value=datetime.timedelta(1), max_value=datetime.timedelta(7))

class IntTestModel(models.Model):
    field = TimedeltaField(min_value=1, max_value=86400)

class FloatTestModel(models.Model):
    field = TimedeltaField(min_value=1.0, max_value=86400.0)

class TimedeltaModelFieldTest(TestCase):
    def test_validate(self):
        test = MinMaxTestModel(
            min=datetime.timedelta(1),
            max=datetime.timedelta(1),
            minmax=datetime.timedelta(1)
        )
        test.full_clean() # This should have met validation requirements.

        test.min = datetime.timedelta(hours=23)
        self.assertRaises(ValidationError, test.full_clean)

        test.min = datetime.timedelta(hours=25)
        test.full_clean()

        test.max = datetime.timedelta(11)
        self.assertRaises(ValidationError, test.full_clean)

        test.max = datetime.timedelta(hours=20)
        test.full_clean()

        test.minmax = datetime.timedelta(0)
        self.assertRaises(ValidationError, test.full_clean)
        test.minmax = datetime.timedelta(22)
        self.assertRaises(ValidationError, test.full_clean)
        test.minmax = datetime.timedelta(6, hours=23, minutes=59, seconds=59)
        test.full_clean()

    def test_from_int(self):
        """
        Check that integers can be used to define the min_value and max_value
        arguments, and that when assigned an integer, TimedeltaField converts
        to timedelta.
        """

        test = IntTestModel()

        # valid
        test.field = 3600
        self.assertEquals(test.field, datetime.timedelta(seconds=3600))
        test.full_clean()

        # invalid
        test.field = 0
        self.assertRaises(ValidationError, test.full_clean)

        # also invalid
        test.field = 86401
        self.assertRaises(ValidationError, test.full_clean)

    def test_from_float(self):
        """
        Check that floats can be used to define the min_value and max_value
        arguments, and that when assigned a float, TimedeltaField converts
        to timedelta.
        """

        test = FloatTestModel()

        # valid
        test.field = 3600.0
        self.assertEquals(test.field, datetime.timedelta(seconds=3600))
        test.full_clean()

        # invalid
        test.field = 0.0
        self.assertRaises(ValidationError, test.full_clean)

        # also invalid
        test.field = 86401.0
        self.assertRaises(ValidationError, test.full_clean)

    def test_deconstruct(self):
        """
        Check that the deconstruct() method of TimedeltaField is returning the
        min_value, max_value and default kwargs as floats.
        """

        field = TimedeltaField(
            min_value=datetime.timedelta(minutes=5),
            max_value=datetime.timedelta(minutes=15),
            default=datetime.timedelta(minutes=30),
        )

        kwargs = field.deconstruct()[3]
        self.assertEqual(kwargs['default'], 1800.0)
        self.assertEqual(kwargs['max_value'], 900.0)
        self.assertEqual(kwargs['min_value'], 300.0)

    def test_load_from_db(self):
        obj = MinMaxTestModel.objects.create(min='2 days', max='2 minutes', minmax='3 days')
        self.assertEquals(datetime.timedelta(2), obj.min)
        self.assertEquals(datetime.timedelta(0, 120), obj.max)
        self.assertEquals(datetime.timedelta(3), obj.minmax)

        obj = MinMaxTestModel.objects.get()
        self.assertEquals(datetime.timedelta(2), obj.min)
        self.assertEquals(datetime.timedelta(0, 120), obj.max)
        self.assertEquals(datetime.timedelta(3), obj.minmax)

def load_tests(loader, tests, ignore):
    tests.addTests(doctest.DocTestSuite(timedelta.helpers))
    tests.addTests(doctest.DocTestSuite(timedelta.forms))
    return tests