Ejemplo n.º 1
0
 def test_add(self):
     s = BusinessDate('20011110')
     e = BusinessDate('20011112')
     self.assertEqual(BusinessDate.add_days(s, e.day),
                      BusinessDate('20011122'))
     self.assertEqual(BusinessDate.add_months(s, 1),
                      BusinessDate('20011210'))
     self.assertEqual(BusinessDate.add_years(s, 1),
                      BusinessDate('20021110'))
Ejemplo n.º 2
0
 def test_add(self):
     s = BusinessDate('20011110')
     e = BusinessDate('20011112')
     self.assertEqual(BusinessDate.add_days(s, e.day), BusinessDate('20011122'))
     self.assertEqual(BusinessDate.add_months(s, 1), BusinessDate('20011210'))
     self.assertEqual(BusinessDate.add_years(s, 1), BusinessDate('20021110'))
Ejemplo n.º 3
0
class BusinessDateUnitTests(unittest.TestCase):
    def setUp(self):
        self.dec31 = BusinessDate(20151231)
        self.jan01 = BusinessDate(20160101)
        self.jan02 = BusinessDate(20160102)
        self.jan04 = BusinessDate(20160104)
        self.jan29 = BusinessDate(20160129)
        self.jan31 = BusinessDate(20160131)
        self.feb01 = BusinessDate(20160201)
        self.feb28 = BusinessDate(20160228)
        self.feb29 = BusinessDate(20160229)
        self.mar31 = BusinessDate(20160331)
        self.jun30 = BusinessDate(20160630)
        self.sep30 = BusinessDate(20160930)

        self.dates = [self.dec31, self.jan01, self.jan02, self.jan04, self.jan29, self.jan31,
                      self.feb01, self.feb28, self.feb29, self.mar31, self.jun30, self.sep30]

    def test_constructors(self):
        self.assertEqual(BusinessDate(date.today()), BusinessDate())
        self.assertEqual(self.jan02, BusinessDate('2016-01-02'))
        self.assertEqual(self.jan02, BusinessDate('01/02/2016'))
        self.assertEqual(self.jan02, BusinessDate('02.01.2016'))
        self.assertEqual(self.jan02, BusinessDate(42371))
        self.assertEqual(self.jan02, BusinessDate(42371.0))
        self.assertEqual(self.jan02, BusinessDate(735965))
        self.assertEqual(self.jan02, BusinessDate(735965.0))
        self.assertEqual([self.jan01, self.jan02], BusinessDate([20160101, 42371]))

    def test_to_string(self):
        self.assertEqual(self.jan02.to_string(), '20160102')
        self.assertEqual(BusinessDate(42371).to_string(), '20160102')

    def test_properties(self):
        self.assertEqual(self.jan01.day, 01)
        self.assertEqual(self.jan01.month, 01)
        self.assertEqual(self.jan01.year, 2016)

    def test_operators(self):
        self.assertEqual(self.jan01 + '2D', self.jan02 + '1D')
        self.assertEqual(self.jan01 - '1D', self.jan02 - '2D')
        self.assertEqual(self.jan02 - '1D' + '1M', self.feb01)
        self.assertRaises(TypeError, lambda: '1D' + self.jan02)
        self.assertEqual(self.jan01 - BusinessPeriod('1D'), self.jan02 - '2D')
        self.assertRaises(TypeError, lambda: BusinessPeriod('1D') + self.jan02)
        self.assertRaises(TypeError, lambda: BusinessPeriod('1D') - self.jan01)
        self.assertEqual(self.dec31.add_period(BusinessPeriod('2B', BusinessHolidays())),
                         self.dec31.add_period(BusinessPeriod('2B'), BusinessHolidays([self.jan02])))

    def test_validations(self):
        self.assertTrue(BusinessDate.is_businessdate(18991229))
        self.assertTrue(BusinessDate.is_businessdate(20160131))
        self.assertTrue(BusinessDate.is_businessdate(20160228))
        self.assertTrue(BusinessDate.is_businessdate(20160229))
        self.assertFalse(BusinessDate.is_businessdate(20160230))
        self.assertFalse(BusinessDate.is_businessdate(20160231))
        self.assertTrue(BusinessDate.is_businessdate(20150228))
        self.assertFalse(BusinessDate.is_businessdate(20150229))
        self.assertFalse(BusinessDate.is_businessdate('xyz'))
        self.assertFalse(BusinessDate.is_businessdate(-125))
        self.assertFalse(BusinessDate.is_businessdate(-20150228))

    def test_calculations(self):
        self.assertEqual(self.jan01.add_days(1), self.jan02)
        self.assertEqual(self.jan01.add_months(1), self.feb01)
        self.assertEqual(self.jan01.add_years(1).to_string(), '20170101')
        self.assertEqual(self.jan01.add_period('2D'), self.jan02 + BusinessPeriod('1D'))
        self.assertEqual(self.jan02.add_period('-2D'), self.jan01 - BusinessPeriod('1D'))
        self.assertEqual(self.jan02.add_period('-1b'), self.jan01 - BusinessPeriod('1b'))
        self.assertNotEqual(BusinessDate(20160630).add_period(BusinessPeriod('2B')),
                            BusinessDate(20160630).add_period(BusinessPeriod('2B', BusinessHolidays(['20160704']))))
        self.assertEqual(self.jan01 + '1b', self.jan02 + '1b')

    def test_cast_to(self):
        self.assertTrue(isinstance(self.jan01.to_date(), date))
        self.assertTrue(isinstance(self.jan01.to_businessdate(), BusinessDate))
        self.assertTrue(isinstance(self.jan01.to_businessperiod(), BusinessPeriod))
        self.assertTrue(isinstance(self.jan01.to_excel(), int))
        self.assertTrue(isinstance(self.jan01.to_ordinal(), int))
        self.assertTrue(isinstance(self.jan01.to_string(), str))
        self.assertTrue(isinstance(self.jan01.to_ymd(), tuple))

    def test_cast_from(self):
        for d in self.dates:
            self.assertEqual(BusinessDate.from_date(d.to_date()), d)
            self.assertEqual(BusinessDate.from_businessdate(d), d)
            self.assertEqual(BusinessDate.from_excel(d.to_excel()), d)
            self.assertEqual(BusinessDate.from_ordinal(d.to_ordinal()), d)
            self.assertEqual(BusinessDate.from_string(d.to_string()), d)
            self.assertEqual(BusinessDate.from_ymd(*d.to_ymd()), d)

    def test_day_count(self):  # The daycount methods are also tested separately
        delta = float((self.mar31.to_date() - self.jan01.to_date()).days)
        total = float(((self.jan01 + '1y').to_date() - self.jan01.to_date()).days)
        self.assertAlmostEqual(self.jan01.get_30_360(self.mar31), 90. / 360.)
        self.assertAlmostEqual(self.jan01.get_act_360(self.mar31), delta / 360.)
        self.assertAlmostEqual(self.jan01.get_act_365(self.mar31), delta / 365.)
        self.assertAlmostEqual(self.jan01.get_act_36525(self.mar31), delta / 365.25)
        self.assertAlmostEqual(self.jan01.get_act_act(self.mar31), delta / total)

    def test_business_day_adjustment(self):
        self.assertEqual(self.jan01.adjust_follow(), BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_mod_follow(), BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_previous(), BusinessDate(20151231))
        self.assertEqual(self.jan01.adjust_mod_previous(), BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_start_of_month(), BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_end_of_month(), BusinessDate(20160129))
        self.assertEqual(self.jan01.adjust_imm(), BusinessDate(20160115))
        self.assertEqual(self.jan01.adjust_cds_imm(), BusinessDate(20160120))

    def test_business_day_is(self):
        self.assertFalse(self.jan01.is_business_day())
        self.assertTrue(BusinessDate.is_leap_year(2016))
        self.assertTrue(BusinessDate.is_businessdate('20160101'))
        self.assertFalse(BusinessDate.is_businessdate('ABC'))
        self.assertFalse(BusinessDate.is_businessdate('20160230'))
        self.assertTrue(BusinessDate.is_businessdate('20160229'))
        self.assertFalse(BusinessDate.is_businessdate('20150229'))

    def test_is_business_date(self):
        d = self.dec31
        holi = BusinessHolidays()
        bdate = BusinessDate.from_ymd(2016, 1, 1)
        is_bday_empty_calendar = bdate.is_business_day(holi)
        self.assertTrue(is_bday_empty_calendar)
        is_bday_default_calendar = bdate.is_business_day()
        self.assertFalse(is_bday_default_calendar)

        target_a= BusinessDate.from_ymd(2016, 1, 4)
        a = d.add_business_days(2, holi)
        self.assertEqual(target_a, a)
        target_b = BusinessDate.from_ymd(2016, 1, 5)
        b = d.add_business_days(2) # default holidays contains the target days, i.e. the 1.1.2016
        self.assertEqual(target_b, b)
Ejemplo n.º 4
0
class BusinessDateUnitTests(unittest.TestCase):
    def setUp(self):
        self.dec31 = BusinessDate(20151231)
        self.jan01 = BusinessDate(20160101)
        self.jan02 = BusinessDate(20160102)
        self.jan04 = BusinessDate(20160104)
        self.jan29 = BusinessDate(20160129)
        self.jan31 = BusinessDate(20160131)
        self.feb01 = BusinessDate(20160201)
        self.feb28 = BusinessDate(20160228)
        self.feb29 = BusinessDate(20160229)
        self.mar31 = BusinessDate(20160331)
        self.jun30 = BusinessDate(20160630)
        self.sep30 = BusinessDate(20160930)

        self.dates = [
            self.dec31, self.jan01, self.jan02, self.jan04, self.jan29,
            self.jan31, self.feb01, self.feb28, self.feb29, self.mar31,
            self.jun30, self.sep30
        ]

    def test_constructors(self):
        self.assertEqual(BusinessDate(date.today()), BusinessDate())
        self.assertEqual(self.jan02, BusinessDate('2016-01-02'))
        self.assertEqual(self.jan02, BusinessDate('01/02/2016'))
        self.assertEqual(self.jan02, BusinessDate('02.01.2016'))
        self.assertEqual(self.jan02, BusinessDate(42371))
        self.assertEqual(self.jan02, BusinessDate(42371.0))
        self.assertEqual(self.jan02, BusinessDate(735965))
        self.assertEqual(self.jan02, BusinessDate(735965.0))
        self.assertEqual([self.jan01, self.jan02],
                         BusinessDate([20160101, 42371]))

    def test_to_string(self):
        self.assertEqual(self.jan02.to_string(), '20160102')
        self.assertEqual(BusinessDate(42371).to_string(), '20160102')

    def test_properties(self):
        self.assertEqual(self.jan01.day, 1)
        self.assertEqual(self.jan01.month, 1)
        self.assertEqual(self.jan01.year, 2016)

    def test_operators(self):
        self.assertEqual(self.jan01 + '2D', self.jan02 + '1D')
        self.assertEqual(self.jan01 - '1D', self.jan02 - '2D')
        self.assertEqual(self.jan02 - '1D' + '1M', self.feb01)
        self.assertRaises(TypeError, lambda: '1D' + self.jan02)
        self.assertEqual(self.jan01 - BusinessPeriod('1D'), self.jan02 - '2D')
        self.assertRaises(TypeError, lambda: BusinessPeriod('1D') + self.jan02)
        self.assertRaises(TypeError, lambda: BusinessPeriod('1D') - self.jan01)
        self.assertEqual(
            self.dec31.add_period(BusinessPeriod('2B', BusinessHolidays())),
            self.dec31.add_period(BusinessPeriod('2B'),
                                  BusinessHolidays([self.jan02])))

    def test_validations(self):
        self.assertTrue(BusinessDate.is_businessdate(18991229))
        self.assertTrue(BusinessDate.is_businessdate(20160131))
        self.assertTrue(BusinessDate.is_businessdate(20160228))
        self.assertTrue(BusinessDate.is_businessdate(20160229))
        self.assertFalse(BusinessDate.is_businessdate(20160230))
        self.assertFalse(BusinessDate.is_businessdate(20160231))
        self.assertTrue(BusinessDate.is_businessdate(20150228))
        self.assertFalse(BusinessDate.is_businessdate(20150229))
        self.assertFalse(BusinessDate.is_businessdate('xyz'))
        self.assertFalse(BusinessDate.is_businessdate(-125))
        self.assertFalse(BusinessDate.is_businessdate(-20150228))

    def test_calculations(self):
        self.assertEqual(self.jan01.add_days(1), self.jan02)
        self.assertEqual(self.jan01.add_months(1), self.feb01)
        self.assertEqual(self.jan01.add_years(1).to_string(), '20170101')
        self.assertEqual(self.jan01.add_period('2D'),
                         self.jan02 + BusinessPeriod('1D'))
        self.assertEqual(self.jan02.add_period('-2D'),
                         self.jan01 - BusinessPeriod('1D'))
        self.assertEqual(self.jan02.add_period('-1b'),
                         self.jan01 - BusinessPeriod('1b'))
        self.assertNotEqual(
            BusinessDate(20160630).add_period(BusinessPeriod('2B')),
            BusinessDate(20160630).add_period(
                BusinessPeriod('2B', BusinessHolidays(['20160704']))))
        self.assertEqual(self.jan01 + '1b', self.jan02 + '1b')

        rng = list(range(1, 10))
        periods = list()
        for y in rng:
            for m in rng:
                for d in rng:
                    periods.append(
                        BusinessPeriod(
                            str(y) + 'y' + str(m) + 'm' + str(d) + 'd'))

        for d in self.dates:
            for p in periods:
                c = d + p
                self.assertEqual((c - d), BusinessPeriod(p), (c, d, c - d, p))

        d = BusinessDate(20160229)
        self.assertEqual(d + '1y' + '1m', BusinessDate(20170328))
        self.assertEqual(d + '1m' + '1y', BusinessDate(20170329))
        self.assertEqual(d + '1y1m', BusinessDate(20170329))

    def test_cast_to(self):
        self.assertTrue(isinstance(self.jan01.to_date(), date))
        self.assertTrue(isinstance(self.jan01.to_businessdate(), BusinessDate))
        self.assertTrue(
            isinstance(self.jan01.to_businessperiod(), BusinessPeriod))
        self.assertTrue(isinstance(self.jan01.to_excel(), int))
        self.assertTrue(isinstance(self.jan01.to_ordinal(), int))
        self.assertTrue(isinstance(self.jan01.to_string(), str))
        self.assertTrue(isinstance(self.jan01.to_ymd(), tuple))

    def test_cast_from(self):
        for d in self.dates:
            self.assertEqual(BusinessDate.from_date(d.to_date()), d)
            self.assertEqual(BusinessDate.from_businessdate(d), d)
            self.assertEqual(BusinessDate.from_excel(d.to_excel()), d)
            self.assertEqual(BusinessDate.from_ordinal(d.to_ordinal()), d)
            self.assertEqual(BusinessDate.from_string(d.to_string()), d)
            self.assertEqual(BusinessDate.from_ymd(*d.to_ymd()), d)

    def test_day_count(
            self):  # The daycount methods are also tested separately
        delta = float((self.mar31.to_date() - self.jan01.to_date()).days)
        total = float(
            ((self.jan01 + '1y').to_date() - self.jan01.to_date()).days)
        self.assertAlmostEqual(self.jan01.get_30_360(self.mar31), 90. / 360.)
        self.assertAlmostEqual(self.jan01.get_act_360(self.mar31),
                               delta / 360.)
        self.assertAlmostEqual(self.jan01.get_act_365(self.mar31),
                               delta / 365.)
        self.assertAlmostEqual(self.jan01.get_act_36525(self.mar31),
                               delta / 365.25)
        self.assertAlmostEqual(self.jan01.get_act_act(self.mar31),
                               delta / total)

    def test_business_day_adjustment(self):
        self.assertEqual(self.jan01.adjust_follow(), BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_mod_follow(),
                         BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_previous(), BusinessDate(20151231))
        self.assertEqual(self.jan01.adjust_mod_previous(),
                         BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_start_of_month(),
                         BusinessDate(20160104))
        self.assertEqual(self.jan01.adjust_end_of_month(),
                         BusinessDate(20160129))
        self.assertEqual(self.jan01.adjust_imm(), BusinessDate(20160115))
        self.assertEqual(self.jan01.adjust_cds_imm(), BusinessDate(20160120))

    def test_business_day_is(self):
        self.assertFalse(self.jan01.is_business_day())
        self.assertTrue(BusinessDate.is_leap_year(2016))
        self.assertTrue(BusinessDate.is_businessdate('20160101'))
        self.assertFalse(BusinessDate.is_businessdate('ABC'))
        self.assertFalse(BusinessDate.is_businessdate('20160230'))
        self.assertTrue(BusinessDate.is_businessdate('20160229'))
        self.assertFalse(BusinessDate.is_businessdate('20150229'))

    def test_is_business_date(self):
        d = self.dec31
        holi = BusinessHolidays()
        bdate = BusinessDate.from_ymd(2016, 1, 1)
        is_bday_empty_calendar = bdate.is_business_day(holi)
        self.assertTrue(is_bday_empty_calendar)
        is_bday_default_calendar = bdate.is_business_day()
        self.assertFalse(is_bday_default_calendar)

        target_a = BusinessDate.from_ymd(2016, 1, 4)
        a = d.add_business_days(2, holi)
        self.assertEqual(target_a, a)
        target_b = BusinessDate.from_ymd(2016, 1, 5)
        b = d.add_business_days(
            2)  # default holidays contains the target days, i.e. the 1.1.2016
        self.assertEqual(target_b, b)