aniso8601.tests.compat.mock.Mock

Here are the examples of the python api aniso8601.tests.compat.mock.Mock taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

24 Examples 7

3 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_date_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'YYYY': '1981', 'MM': '04', 'DD':'05'}

        mockBuilder.build_date.return_value = expectedargs

        result = parse_date('1981-04-05', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_date.assert_called_once_with(**expectedargs)

    def test_parse_year(self):

3 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_year(self):
        testtuples = (('2013', {'YYYY': '2013'}),
                      ('0001', {'YYYY': '0001'}),
                      ('1', {'YYYY': '1'}),
                      ('19', {'YYYY': '19'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_date.return_value = testtuple[1]

            result = _parse_year(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_date.assert_called_once_with(**testtuple[1])

    def test_parse_calendar_day(self):

3 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_calendar_day(self):
        testtuples = (('1981-04-05', {'YYYY': '1981', 'MM': '04', 'DD': '05'}),
                      ('19810405', {'YYYY': '1981', 'MM': '04', 'DD': '05'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_date.return_value = testtuple[1]

            result = _parse_calendar_day(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_date.assert_called_once_with(**testtuple[1])

    def test_parse_calendar_month(self):

3 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_calendar_month(self):
        testtuples = (('1981-04', {'YYYY': '1981', 'MM': '04'}),)

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_date.return_value = testtuple[1]

            result = _parse_calendar_month(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_date.assert_called_once_with(**testtuple[1])

    def test_parse_calendar_month_nohyphen(self):

3 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_ordinal_date(self):
        testtuples = (('1981-095', {'YYYY': '1981', 'DDD': '095'}),
                      ('1981095', {'YYYY': '1981', 'DDD': '095'}),
                      ('1981365', {'YYYY': '1981', 'DDD': '365'}),
                      ('1980366', {'YYYY': '1980', 'DDD': '366'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_date.return_value = testtuple[1]

            result = _parse_ordinal_date(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_date.assert_called_once_with(**testtuple[1])

3 Source : test_duration.py
with MIT License
from DiptoChakrabarty

    def test_parse_duration_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'PnY': '1', 'PnM': '2', 'PnD': '3',
                        'TnH': '4', 'TnM': '54', 'TnS': '6'}

        mockBuilder.build_duration.return_value = expectedargs

        result = parse_duration('P1Y2M3DT4H54M6S', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_duration.assert_called_once_with(**expectedargs)

    def test_parse_duration_nop(self):

3 Source : test_time.py
with MIT License
from DiptoChakrabarty

    def test_parse_datetime_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = (('1981', None, None, None, None, '095', 'date'),
                        ('23', '21', '28.512400',
                         (True, None, '12', '34', '-12:34', 'timezone'),
                         'time'))

        mockBuilder.build_datetime.return_value = expectedargs

        result = parse_datetime('1981095T23:21:28.512400-12:34',
                                builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_datetime.assert_called_once_with(*expectedargs)

    def test_parse_hour(self):

3 Source : test_duration.py
with MIT License
from yassine-youcefi

    def test_parse_duration_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'PnY': '1', 'PnM': '2', 'PnD': '3',
                        'TnH': '4', 'TnM': '54', 'TnS': '6'}

        mockBuilder.build_duration.return_value = expectedargs

        result = parse_duration('P1Y2M3DT4H54M6S', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_duration.assert_called_once_with(**expectedargs)

    def test_parse_duration_badtype(self):

0 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_week_day(self):
        testtuples = (('2004-W53-6', {'YYYY': '2004', 'Www': '53', 'D': '6'}),
                      ('2009-W01-1', {'YYYY': '2009', 'Www': '01', 'D': '1'}),
                      ('2009-W53-7', {'YYYY': '2009', 'Www': '53', 'D': '7'}),
                      ('2010-W01-1', {'YYYY': '2010', 'Www': '01', 'D': '1'}),
                      ('2004W536', {'YYYY': '2004', 'Www': '53', 'D': '6'}),
                      ('2009W011', {'YYYY': '2009', 'Www': '01', 'D': '1'}),
                      ('2009W537', {'YYYY': '2009', 'Www': '53', 'D': '7'}),
                      ('2010W011', {'YYYY': '2010', 'Www': '01', 'D': '1'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_date.return_value = testtuple[1]

            result = _parse_week_day(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_date.assert_called_once_with(**testtuple[1])

    def test_parse_week(self):

0 Source : test_date.py
with MIT License
from DiptoChakrabarty

    def test_parse_week(self):
        testtuples = (('2004-W53', {'YYYY': '2004', 'Www': '53'}),
                      ('2009-W01', {'YYYY': '2009', 'Www': '01'}),
                      ('2009-W53', {'YYYY': '2009', 'Www': '53'}),
                      ('2010-W01', {'YYYY': '2010', 'Www': '01'}),
                      ('2004W53', {'YYYY': '2004', 'Www': '53'}),
                      ('2009W01', {'YYYY': '2009', 'Www': '01'}),
                      ('2009W53', {'YYYY': '2009', 'Www': '53'}),
                      ('2010W01', {'YYYY': '2010', 'Www': '01'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_date.return_value = testtuple[1]

            result = _parse_week(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_date.assert_called_once_with(**testtuple[1])

    def test_parse_ordinal_date(self):

0 Source : test_duration.py
with MIT License
from DiptoChakrabarty

    def test_parse_duration_prescribed(self):
        testtuples = (('P1Y2M3DT4H54M6S', {'PnY': '1', 'PnM': '2',
                                           'PnD': '3', 'TnH': '4',
                                           'TnM': '54', 'TnS': '6'}),
                      ('P1Y2M3DT4H54M6,5S', {'PnY': '1', 'PnM': '2',
                                             'PnD': '3', 'TnH': '4',
                                             'TnM': '54', 'TnS': '6.5'}),
                      ('P1Y2M3DT4H54M6.5S', {'PnY': '1', 'PnM': '2',
                                             'PnD': '3', 'TnH': '4',
                                             'TnM': '54', 'TnS': '6.5'}),
                      ('PT4H54M6,5S', {'PnY': None, 'PnM': None, 'PnD': None,
                                       'TnH': '4', 'TnM': '54', 'TnS': '6.5'}),
                      ('PT4H54M6.5S', {'PnY': None, 'PnM': None, 'PnD': None,
                                       'TnH': '4', 'TnM': '54', 'TnS': '6.5'}),
                      ('P1Y2M3D', {'PnY': '1', 'PnM': '2',
                                   'PnW': None, 'PnD': '3'}),
                      ('P1Y2M3,5D', {'PnY': '1', 'PnM': '2',
                                     'PnW': None, 'PnD': '3.5'}),
                      ('P1Y2M3.5D', {'PnY': '1', 'PnM': '2',
                                     'PnW': None, 'PnD': '3.5'}),
                      ('P1Y', {'PnY': '1', 'PnM': None,
                               'PnW': None, 'PnD': None}),
                      ('P1,5Y', {'PnY': '1.5', 'PnM': None, 'PnW': None,
                                 'PnD': None}),
                      ('P1.5Y', {'PnY': '1.5', 'PnM': None, 'PnW': None,
                                 'PnD': None}),
                      ('P1M', {'PnY': None, 'PnM': '1', 'PnW': None,
                               'PnD': None}),
                      ('P1,5M', {'PnY': None, 'PnM': '1.5', 'PnW': None,
                                 'PnD':None}),
                      ('P1.5M', {'PnY': None, 'PnM': '1.5', 'PnW': None,
                                 'PnD':None}),
                      ('P1W', {'PnY': None, 'PnM': None, 'PnW': '1',
                               'PnD': None}),
                      ('P1,5W', {'PnY': None, 'PnM': None, 'PnW': '1.5',
                                 'PnD': None}),
                      ('P1.5W', {'PnY': None, 'PnM': None, 'PnW': '1.5',
                                 'PnD': None}),
                      ('P1D', {'PnY': None, 'PnM': None, 'PnW': None,
                               'PnD': '1'}),
                      ('P1,5D', {'PnY': None, 'PnM': None, 'PnW': None,
                                 'PnD': '1.5'}),
                      ('P1.5D', {'PnY': None, 'PnM': None, 'PnW': None,
                                 'PnD': '1.5'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_duration.return_value = testtuple[1]

            result = _parse_duration_prescribed(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_duration.assert_called_once_with(**testtuple[1])

    def test_parse_duration_prescribed_negative(self):

0 Source : test_duration.py
with MIT License
from DiptoChakrabarty

    def test_parse_duration_prescribed_notime(self):
        testtuples = (('P1Y2M3D', {'PnY': '1', 'PnM': '2',
                                   'PnW': None, 'PnD': '3'}),
                      ('P1Y2M3,5D', {'PnY': '1', 'PnM': '2',
                                     'PnW': None, 'PnD': '3.5'}),
                      ('P1Y2M3.5D', {'PnY': '1', 'PnM': '2',
                                     'PnW': None, 'PnD': '3.5'}),
                      ('P1Y', {'PnY': '1', 'PnM': None,
                               'PnW': None, 'PnD': None}),
                      ('P1,5Y', {'PnY': '1.5', 'PnM': None, 'PnW': None,
                                 'PnD': None}),
                      ('P1.5Y', {'PnY': '1.5', 'PnM': None, 'PnW': None,
                                 'PnD': None}),
                      ('P1M', {'PnY': None, 'PnM': '1', 'PnW': None,
                               'PnD': None}),
                      ('P1,5M', {'PnY': None, 'PnM': '1.5', 'PnW': None,
                                 'PnD':None}),
                      ('P1.5M', {'PnY': None, 'PnM': '1.5', 'PnW': None,
                                 'PnD':None}),
                      ('P1W', {'PnY': None, 'PnM': None, 'PnW': '1',
                               'PnD': None}),
                      ('P1,5W', {'PnY': None, 'PnM': None, 'PnW': '1.5',
                                 'PnD': None}),
                      ('P1.5W', {'PnY': None, 'PnM': None, 'PnW': '1.5',
                                 'PnD': None}),
                      ('P1D', {'PnY': None, 'PnM': None, 'PnW': None,
                               'PnD': '1'}),
                      ('P1,5D', {'PnY': None, 'PnM': None, 'PnW': None,
                                 'PnD': '1.5'}),
                      ('P1.5D', {'PnY': None, 'PnM': None, 'PnW': None,
                                 'PnD': '1.5'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_duration.return_value = testtuple[1]

            result = _parse_duration_prescribed_notime(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_duration.assert_called_once_with(**testtuple[1])

    def test_parse_duration_prescribed_notime_timepart(self):

0 Source : test_duration.py
with MIT License
from DiptoChakrabarty

    def test_parse_duration_prescribed_time(self):
        testtuples = (('P1Y2M3DT4H54M6S', {'PnY': '1', 'PnM': '2',
                                           'PnD': '3', 'TnH': '4',
                                           'TnM': '54', 'TnS': '6'}),
                      ('P1Y2M3DT4H54M6,5S', {'PnY': '1', 'PnM': '2',
                                             'PnD': '3', 'TnH': '4',
                                             'TnM': '54', 'TnS': '6.5'}),
                      ('P1Y2M3DT4H54M6.5S', {'PnY': '1', 'PnM': '2',
                                             'PnD': '3', 'TnH': '4',
                                             'TnM': '54', 'TnS': '6.5'}),
                      ('PT4H54M6,5S', {'PnY': None, 'PnM': None, 'PnD': None,
                                       'TnH': '4', 'TnM': '54', 'TnS': '6.5'}),
                      ('PT4H54M6.5S', {'PnY': None, 'PnM': None, 'PnD': None,
                                       'TnH': '4', 'TnM': '54', 'TnS': '6.5'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_duration.return_value = testtuple[1]

            result = _parse_duration_prescribed_time(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_duration.assert_called_once_with(**testtuple[1])

    def test_parse_duration_prescribed_time_timeindate(self):

0 Source : test_duration.py
with MIT License
from DiptoChakrabarty

    def test_parse_duration_combined(self):
        testtuples = (('P0003-06-04T12:30:05', {'PnY': '0003', 'PnM': '06',
                                                'PnD': '04', 'TnH': '12',
                                                'TnM': '30', 'TnS': '05'}),
                      ('P0003-06-04T12:30:05,5', {'PnY': '0003', 'PnM': '06',
                                                  'PnD': '04', 'TnH': '12',
                                                  'TnM': '30', 'TnS': '05.5'}),
                      ('P0003-06-04T12:30:05.5', {'PnY': '0003', 'PnM': '06',
                                                  'PnD': '04', 'TnH': '12',
                                                  'TnM': '30', 'TnS': '05.5'}),
                      ('P0001-02-03T14:43:59.9999997', {'PnY': '0001',
                                                        'PnM': '02',
                                                        'PnD': '03',
                                                        'TnH': '14',
                                                        'TnM': '43',
                                                        'TnS':
                                                        '59.9999997'}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_duration.return_value = testtuple[1]

            result = _parse_duration_combined(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_duration.assert_called_once_with(**testtuple[1])

    def test_parse_duration_combined_suffixgarbage(self):

0 Source : test_interval.py
with MIT License
from DiptoChakrabarty

    def test_parse_interval_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'end': (('1981', '04', '05', None, None, None, 'date'),
                                ('01', '01', '00', None, 'time'), 'datetime'),
                        'duration':(None, '1', None, None, None, None, None,
                                    'duration')}

        mockBuilder.build_interval.return_value = expectedargs

        result = parse_interval('P1M/1981-04-05T01:01:00', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'start': ('2014', '11', '12', None, None, None,
                                  'date'),
                        'duration': (None, None, None, None, '1', None, None,
                                     'duration')}

        mockBuilder.build_interval.return_value = expectedargs

        result = parse_interval('2014-11-12/PT1H', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'start': (('1980', '03', '05', None, None, None,
                                   'date'),
                                  ('01', '01', '00', None, 'time'),
                                  'datetime'),
                        'end': (('1981', '04', '05', None, None, None,
                                 'date'),
                                ('01', '01', '00', None, 'time'),
                                'datetime')}

        mockBuilder.build_interval.return_value = expectedargs

        result = parse_interval('1980-03-05T01:01:00/1981-04-05T01:01:00',
                       builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

    def test_parse_interval_repeating(self):

0 Source : test_interval.py
with MIT License
from DiptoChakrabarty

    def test_parse_repeating_interval_mockbuilder(self):
        mockBuilder = mock.Mock()

        args = {'R': False, 'Rnn': '3',
                'interval': (('1981', '04', '05', None, None, None,
                              'date'),
                             None,
                             (None, None, None, '1', None, None,
                              None, 'duration'),
                             'interval')}

        mockBuilder.build_repeating_interval.return_value = args

        result = parse_repeating_interval('R3/1981-04-05/P1D',
                                          builder=mockBuilder)

        self.assertEqual(result, args)
        mockBuilder.build_repeating_interval.assert_called_once_with(**args)

        mockBuilder = mock.Mock()

        args = {'R': False, 'Rnn': '11',
                'interval': (None,
                             (('1980', '03', '05', None, None, None,
                               'date'),
                              ('01', '01', '00', None, 'time'),
                              'datetime'),
                             (None, None, None, None, '1', '2',
                              None, 'duration'),
                             'interval')}

        mockBuilder.build_repeating_interval.return_value = args

        result = parse_repeating_interval('R11/PT1H2M/1980-03-05T01:01:00',
                                          builder=mockBuilder)

        self.assertEqual(result, args)
        mockBuilder.build_repeating_interval.assert_called_once_with(**args)

        mockBuilder = mock.Mock()

        args = {'R': True, 'Rnn': None,
                'interval': (None,
                             (('1980', '03', '05', None, None, None,
                               'date'),
                              ('01', '01', '00', None, 'time'),
                              'datetime'),
                             (None, None, None, None, '1', '2',
                              None, 'duration'),
                             'interval')}

        mockBuilder.build_repeating_interval.return_value = args

        result = parse_repeating_interval('R/PT1H2M/1980-03-05T01:01:00',
                                          builder=mockBuilder)

        self.assertEqual(result, args)
        mockBuilder.build_repeating_interval.assert_called_once_with(**args)

    def test_parse_repeating_interval_suffixgarbage(self):

0 Source : test_interval.py
with MIT License
from DiptoChakrabarty

    def test_parse_interval_internal(self):
        #Test the internal _parse_interval function
        testtuples = (('P1M/1981-04-05T01:01:00',
                       {'end': (('1981', '04', '05', None, None, None, 'date'),
                                ('01', '01', '00', None, 'time'), 'datetime'),
                        'duration': (None, '1', None, None, None, None, None,
                                     'duration')}),
                      ('P1M/1981-04-05',
                       {'end': ('1981', '04', '05', None, None, None, 'date'),
                        'duration': (None, '1', None, None, None, None, None,
                                     'duration')}),
                      ('P1,5Y/2018-03-06',
                       {'end': ('2018', '03', '06', None, None, None, 'date'),
                        'duration': ('1.5', None, None, None, None, None, None,
                                     'duration')}),
                      ('P1.5Y/2018-03-06',
                       {'end': ('2018', '03', '06', None, None, None, 'date'),
                        'duration': ('1.5', None, None, None, None, None, None,
                                     'duration')}),
                      ('PT1H/2014-11-12',
                       {'end': ('2014', '11', '12', None, None, None, 'date'),
                        'duration': (None, None, None, None, '1', None, None,
                                     'duration')}),
                      ('PT4H54M6.5S/2014-11-12',
                       {'end': ('2014', '11', '12', None, None, None, 'date'),
                        'duration': (None, None, None, None, '4', '54', '6.5',
                                     'duration')}),
                      #Make sure we truncate, not round
                      #https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
                      ('PT0.0000001S/2018-03-06',
                       {'end': ('2018', '03', '06', None, None, None, 'date'),
                        'duration': (None, None, None,
                                     None, None, None,
                                     '0.0000001', 'duration')}),
                      ('PT2.0000048S/2018-03-06',
                       {'end': ('2018', '03', '06', None, None, None, 'date'),
                        'duration': (None, None, None,
                                     None, None, None,
                                     '2.0000048', 'duration')}),
                      ('1981-04-05T01:01:00/P1M1DT1M',
                       {'start': (('1981', '04', '05',
                                   None, None, None, 'date'),
                                  ('01', '01', '00', None, 'time'),
                                  'datetime'),
                        'duration': (None, '1', None,
                                     '1', None, '1', None, 'duration')}),
                      ('1981-04-05/P1M1D',
                       {'start': ('1981', '04', '05',
                                  None, None, None, 'date'),
                        'duration': (None, '1', None,
                                     '1', None, None, None, 'duration')}),
                      ('2018-03-06/P2,5M',
                       {'start': ('2018', '03', '06',
                                  None, None, None, 'date'),
                        'duration': (None, '2.5', None,
                                     None, None, None, None, 'duration')}),
                      ('2018-03-06/P2.5M',
                       {'start': ('2018', '03', '06',
                                  None, None, None, 'date'),
                        'duration': (None, '2.5', None,
                                     None, None, None, None, 'duration')}),
                      ('2014-11-12/PT1H',
                       {'start': ('2014', '11', '12',
                                  None, None, None, 'date'),
                        'duration': (None, None, None,
                                     None, '1', None, None, 'duration')}),
                      ('2014-11-12/PT4H54M6.5S',
                       {'start': ('2014', '11', '12',
                                  None, None, None, 'date'),
                        'duration': (None, None, None,
                                     None, '4', '54', '6.5', 'duration')}),
                      #Make sure we truncate, not round
                      #https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
                      ('2018-03-06/PT0.0000001S',
                       {'start': ('2018', '03', '06',
                                  None, None, None, 'date'),
                        'duration': (None, None, None,
                                     None, None, None,
                                     '0.0000001', 'duration')}),
                      ('2018-03-06/PT2.0000048S',
                       {'start': ('2018', '03', '06',
                                  None, None, None, 'date'),
                        'duration': (None, None, None,
                                     None, None, None,
                                     '2.0000048', 'duration')}),
                      ('1980-03-05T01:01:00/1981-04-05T01:01:00',
                       {'start': (('1980', '03', '05',
                                   None, None, None, 'date'),
                                  ('01', '01', '00',
                                   None, 'time'), 'datetime'),
                        'end': (('1981', '04', '05',
                                 None, None, None, 'date'),
                                ('01', '01', '00',
                                 None, 'time'), 'datetime')}),
                      ('1980-03-05T01:01:00/1981-04-05',
                       {'start': (('1980', '03', '05',
                                   None, None, None, 'date'),
                                  ('01', '01', '00',
                                   None, 'time'), 'datetime'),
                        'end': ('1981', '04', '05',
                                None, None, None, 'date')}),
                      ('1980-03-05/1981-04-05T01:01:00',
                       {'start': ('1980', '03', '05',
                                  None, None, None, 'date'),
                        'end': (('1981', '04', '05',
                                 None, None, None, 'date'),
                                ('01', '01', '00',
                                 None, 'time'), 'datetime')}),
                      ('1980-03-05/1981-04-05',
                       {'start': ('1980', '03', '05',
                                  None, None, None, 'date'),
                        'end': ('1981', '04', '05',
                                None, None, None, 'date')}),
                      ('1981-04-05/1980-03-05',
                       {'start': ('1981', '04', '05',
                                  None, None, None, 'date'),
                        'end': ('1980', '03', '05',
                                None, None, None, 'date')}),
                      #Make sure we truncate, not round
                      #https://bitbucket.org/nielsenb/aniso8601/issues/10/sub-microsecond-precision-in-durations-is
                      ('1980-03-05T01:01:00.0000001/'
                       '1981-04-05T14:43:59.9999997',
                       {'start': (('1980', '03', '05',
                                   None, None, None, 'date'),
                                  ('01', '01', '00.0000001',
                                   None, 'time'), 'datetime'),
                        'end': (('1981', '04', '05',
                                 None, None, None, 'date'),
                                ('14', '43', '59.9999997', None, 'time'),
                                'datetime')}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()
            mockBuilder.build_interval.return_value = testtuple[1]

            result = _parse_interval(testtuple[0], mockBuilder)

            self.assertEqual(result, testtuple[1])
            mockBuilder.build_interval.assert_called_once_with(**testtuple[1])

        #Test different separators
        expectedargs = {'start': (('1980', '03', '05',
                                   None, None, None,
                                   'date'),
                                  ('01', '01', '00',
                                   None, 'time'),
                                  'datetime'),
                        'end': (('1981', '04', '05',
                                 None, None, None,
                                 'date'),
                                ('01', '01', '00',
                                 None, 'time'),
                                'datetime')}

        mockBuilder = mock.Mock()
        mockBuilder.build_interval.return_value = expectedargs

        result = _parse_interval('1980-03-05T01:01:00--1981-04-05T01:01:00',
                                 mockBuilder,
                                 intervaldelimiter='--')

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

        expectedargs = {'start': (('1980', '03', '05',
                                   None, None, None,
                                   'date'),
                                  ('01', '01', '00',
                                   None, 'time'),
                                  'datetime'),
                        'end': (('1981', '04', '05',
                                 None, None, None,
                                 'date'),
                                ('01', '01', '00',
                                 None, 'time'),
                                'datetime')}

        mockBuilder = mock.Mock()
        mockBuilder.build_interval.return_value = expectedargs

        _parse_interval('1980-03-05 01:01:00/1981-04-05 01:01:00',
                        mockBuilder,
                        datetimedelimiter=' ')

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

0 Source : test_time.py
with MIT License
from DiptoChakrabarty

    def test_parse_time_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'hh': '01', 'mm': '23', 'ss': '45', 'tz': None}

        mockBuilder.build_time.return_value = expectedargs

        result = parse_time('01:23:45', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_time.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'hh': '23', 'mm': '21', 'ss': '28.512400',
                        'tz': (False, None, '00', '00', '+00:00', 'timezone')}

        mockBuilder.build_time.return_value = expectedargs

        result = parse_time('232128.512400+00:00', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_time.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'hh': '23', 'mm': '21', 'ss': '28.512400',
                        'tz': (False, None, '11', '15', '+11:15', 'timezone')}

        mockBuilder.build_time.return_value = expectedargs

        result = parse_time('23:21:28.512400+11:15', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_time.assert_called_once_with(**expectedargs)

    def test_parse_datetime(self):

0 Source : test_time.py
with MIT License
from DiptoChakrabarty

    def test_parse_hour(self):
        testtuples = (('01', None, {'hh': '01', 'tz': None}),
                      ('24', None, {'tz': None}),
                      ('01.4567', None, {'hh': '01.4567', 'tz': None}),
                      ('12.5', None, {'hh': '12.5', 'tz': None}),
                      ('08', (True, None, '12', '34', '-12:34', 'timezone'),
                       {'hh': '08', 'tz':
                        (True, None, '12', '34', '-12:34', 'timezone')}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()

            mockBuilder.build_time.return_value = testtuple[2]

            result = _parse_hour(testtuple[0], testtuple[1], mockBuilder)

            self.assertEqual(result, testtuple[2])
            mockBuilder.build_time.assert_called_once_with(**testtuple[2])

    def test_parse_minute_time(self):

0 Source : test_time.py
with MIT License
from DiptoChakrabarty

    def test_parse_minute_time(self):
        testtuples = (('01:23', None, {'hh': '01', 'mm': '23', 'tz': None}),
                      ('24:00', None, {'hh': '24', 'mm': '00', 'tz': None}),
                      ('01:23.4567', None, {'hh': '01', 'mm': '23.4567',
                                            'tz': None}),
                      ('0123', None, {'hh': '01', 'mm': '23', 'tz': None}),
                      ('2400', None, {'hh': '24', 'mm': '00', 'tz': None}),
                      ('0123.4567', None, {'hh': '01', 'mm': '23.4567',
                                           'tz': None}),
                      ('08:13', (True, None, '12', '34', '-12:34', 'timezone'),
                       {'hh': '08', 'mm': '13',
                        'tz': (True, None, '12', '34', '-12:34', 'timezone')}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()

            mockBuilder.build_time.return_value = testtuple[2]

            result = _parse_minute_time(testtuple[0], testtuple[1],
                                        mockBuilder)

            self.assertEqual(result, testtuple[2])
            mockBuilder.build_time.assert_called_once_with(**testtuple[2])

    def test_parse_second_time(self):

0 Source : test_time.py
with MIT License
from DiptoChakrabarty

    def test_parse_second_time(self):
        testtuples = (('01:23:45', None, {'hh': '01', 'mm': '23',
                                          'ss': '45', 'tz': None}),
                      ('24:00:00', None, {'hh': '24', 'mm': '00',
                                          'ss': '00', 'tz': None}),
                      ('23:21:28.512400', None, {'hh': '23', 'mm': '21',
                                                 'ss': '28.512400',
                                                 'tz': None}),
                      ('14:43:59.9999997', None, {'hh': '14', 'mm': '43',
                                                  'ss': '59.9999997',
                                                  'tz': None}),
                      ('012345', None, {'hh': '01', 'mm': '23',
                                        'ss': '45', 'tz': None}),
                      ('240000', None, {'hh': '24', 'mm': '00',
                                        'ss': '00', 'tz': None}),
                      ('232128.512400', None, {'hh': '23', 'mm': '21',
                                               'ss': '28.512400', 'tz': None}),
                      ('144359.9999997', None, {'hh': '14', 'mm': '43',
                                                'ss': '59.9999997',
                                                'tz': None}),
                      ('08:22:21',
                       (True, None, '12', '34', '-12:34', 'timezone'),
                       {'hh': '08', 'mm': '22', 'ss': '21',
                        'tz': (True, None, '12', '34', '-12:34', 'timezone')}))

        for testtuple in testtuples:
            mockBuilder = mock.Mock()

            mockBuilder.build_time.return_value = testtuple[2]

            result = _parse_second_time(testtuple[0], testtuple[1],
                                        mockBuilder)

            self.assertEqual(result, testtuple[2])
            mockBuilder.build_time.assert_called_once_with(**testtuple[2])

    def test_split_tz(self):

0 Source : test_timezone.py
with MIT License
from DiptoChakrabarty

    def test_parse_timezone_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'negative': False, 'Z': True, 'name': 'Z'}

        mockBuilder.build_timezone.return_value = expectedargs

        result = parse_timezone('Z', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_timezone.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'negative': False, 'hh': '00', 'mm': '00',
                        'name': '+00:00'}

        mockBuilder.build_timezone.return_value = expectedargs

        result = parse_timezone('+00:00', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_timezone.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'negative': True, 'hh': '01', 'mm': '23',
                        'name': '-01:23'}

        mockBuilder.build_timezone.return_value = expectedargs

        result = parse_timezone('-01:23', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_timezone.assert_called_once_with(**expectedargs)

    def test_parse_timezone_badstr(self):

0 Source : test_interval.py
with MIT License
from yassine-youcefi

    def test_parse_interval_mockbuilder(self):
        mockBuilder = mock.Mock()

        expectedargs = {'end': (('1981', '04', '05', None, None, None, 'date'),
                                ('01', '01', '00', None, 'time'), 'datetime'),
                        'duration':(None, '1', None, None, None, None, None,
                                    'duration')}

        mockBuilder.build_interval.return_value = expectedargs

        result = parse_interval('P1M/1981-04-05T01:01:00', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'start': ('2014', '11', '12', None, None, None,
                                  'date'),
                        'duration': (None, None, None, None, '1', None, None,
                                     'duration')}

        mockBuilder.build_interval.return_value = expectedargs

        result = parse_interval('2014-11-12/PT1H', builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

        mockBuilder = mock.Mock()

        expectedargs = {'start': (('1980', '03', '05', None, None, None,
                                   'date'),
                                  ('01', '01', '00', None, 'time'),
                                  'datetime'),
                        'end': (('1981', '04', '05', None, None, None,
                                 'date'),
                                ('01', '01', '00', None, 'time'),
                                'datetime')}

        mockBuilder.build_interval.return_value = expectedargs

        result = parse_interval('1980-03-05T01:01:00/1981-04-05T01:01:00',
                       builder=mockBuilder)

        self.assertEqual(result, expectedargs)
        mockBuilder.build_interval.assert_called_once_with(**expectedargs)

    def test_parse_interval_badtype(self):

0 Source : test_interval.py
with MIT License
from yassine-youcefi

    def test_parse_repeating_interval_mockbuilder(self):
        mockBuilder = mock.Mock()

        args = {'R': False, 'Rnn': '3',
                'interval': (('1981', '04', '05', None, None, None,
                              'date'),
                             None,
                             (None, None, None, '1', None, None,
                              None, 'duration'),
                             'interval')}

        mockBuilder.build_repeating_interval.return_value = args

        result = parse_repeating_interval('R3/1981-04-05/P1D',
                                          builder=mockBuilder)

        self.assertEqual(result, args)
        mockBuilder.build_repeating_interval.assert_called_once_with(**args)

        mockBuilder = mock.Mock()

        args = {'R': False, 'Rnn': '11',
                'interval': (None,
                             (('1980', '03', '05', None, None, None,
                               'date'),
                              ('01', '01', '00', None, 'time'),
                              'datetime'),
                             (None, None, None, None, '1', '2',
                              None, 'duration'),
                             'interval')}

        mockBuilder.build_repeating_interval.return_value = args

        result = parse_repeating_interval('R11/PT1H2M/1980-03-05T01:01:00',
                                          builder=mockBuilder)

        self.assertEqual(result, args)
        mockBuilder.build_repeating_interval.assert_called_once_with(**args)

        mockBuilder = mock.Mock()

        args = {'R': True, 'Rnn': None,
                'interval': (None,
                             (('1980', '03', '05', None, None, None,
                               'date'),
                              ('01', '01', '00', None, 'time'),
                              'datetime'),
                             (None, None, None, None, '1', '2',
                              None, 'duration'),
                             'interval')}

        mockBuilder.build_repeating_interval.return_value = args

        result = parse_repeating_interval('R/PT1H2M/1980-03-05T01:01:00',
                                          builder=mockBuilder)

        self.assertEqual(result, args)
        mockBuilder.build_repeating_interval.assert_called_once_with(**args)

    def test_parse_repeating_interval_badtype(self):