コード例 #1
0
ファイル: test_pyson.py プロジェクト: xyzlat/trytond
    def test_DateTime_start_invalid(self):
        "Test DateTime with invalid start"
        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(start=pyson.Eval('foo')))

        self.assertIsInstance(
            pyson.PYSONDecoder({
                'foo': 'bar'
            }).decode(eval), datetime.datetime)
コード例 #2
0
ファイル: test_pyson.py プロジェクト: xyzlat/trytond
    def test_DateTime_start_datetime(self):
        "Test DateTime with start as date"
        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(start=pyson.Eval('date')))

        date = datetime.date(2000, 1, 1)
        self.assertEqual(
            pyson.PYSONDecoder({
                'date': date
            }).decode(eval), datetime.datetime(2000, 1, 1, 0, 0))
コード例 #3
0
ファイル: test_pyson.py プロジェクト: xyzlat/trytond
    def test_DateTime_start(self):
        "Test DateTime with start"
        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(start=pyson.Eval('datetime')))

        datetime_ = datetime.datetime(2000, 1, 1, 12, 0)
        self.assertEqual(
            pyson.PYSONDecoder({
                'datetime': datetime_
            }).decode(eval), datetime_)
コード例 #4
0
    def test_noeval(self):
        decoder = pyson.PYSONDecoder(noeval=True)
        encoder = pyson.PYSONEncoder()

        for instance in [
                pyson.Eval('test', 0),
                pyson.Not(True),
                pyson.Bool('test'),
                pyson.And(True, False, True),
                pyson.Or(False, True, True),
                pyson.Equal('foo', 'bar'),
                pyson.Greater(1, 0),
                pyson.Less(0, 1),
                pyson.If(True, 'foo', 'bar'),
                pyson.Get({'foo': 'bar'}, 'foo', 'default'),
                pyson.In('foo', ['foo', 'bar']),
                pyson.Date(),
                pyson.DateTime(),
                pyson.Len([1, 2, 3]),
                ]:
            self.assertEqual(decoder.decode(encoder.encode(instance)).pyson(),
                instance.pyson())
コード例 #5
0
    def test_DateTime(self):
        'Test pyson.DateTime'
        self.assertEqual(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, -1, 12, -7, 2, 15, 30,
                           1).pyson(), {
                               '__class__': 'DateTime',
                               'y': 2010,
                               'M': 1,
                               'd': 12,
                               'h': 10,
                               'm': 30,
                               's': 20,
                               'ms': 0,
                               'dy': -1,
                               'dM': 12,
                               'dd': -7,
                               'dh': 2,
                               'dm': 15,
                               'ds': 30,
                               'dms': 1,
                           })

        self.assertRaises(AssertionError, pyson.DateTime, 'test', 1, 12, 10,
                          30, 20, 0, -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 'test', 12, 10,
                          30, 20, 0, -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 'test', 10,
                          30, 20, 0, -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 'test',
                          30, 20, 0, -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10,
                          'test', 20, 0, -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          'test', 0, -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 'test', -1, 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, 'test', 12, -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, -1, 'test', -7, 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, -1, 12, 'test', 2, 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, -1, 12, -7, 'test', 15, 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, -1, 12, -7, 2, 'test', 30, 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, -1, 12, -7, 2, 15, 'test', 1)
        self.assertRaises(AssertionError, pyson.DateTime, 2010, 1, 12, 10, 30,
                          20, 0, -1, 12, -7, 2, 15, 30, 'test')

        self.assertEqual(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, -1, 12, -7, 2, 15, 30,
                           1).types(), set([datetime.datetime]))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 1, 12, 10, 30, 20, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, -1))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2009, 1, 12, 10, 30, 20, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, 0, 12))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2011, 1, 12, 10, 30, 20, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, 0, 0, -7))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 1, 5, 10, 30, 20, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, 0, 0, 0, 12))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 1, 12, 22, 30, 20, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, 0, 0, 0, 0, -30))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 1, 12, 10, 0, 20, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, 0, 0, 0, 0, 0, 30))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 1, 12, 10, 30, 50, 0))

        eval = pyson.PYSONEncoder().encode(
            pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, 0, 0, 0, 0, 0, 0, 200))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 1, 12, 10, 30, 20, 200))

        eval = pyson.PYSONEncoder().encode(
            datetime.datetime(2010, 2, 22, 10, 30, 20, 200))
        self.assertEqual(pyson.PYSONDecoder().decode(eval),
                         datetime.datetime(2010, 2, 22, 10, 30, 20, 200))

        self.assertEqual(
            repr(
                pyson.DateTime(2010, 1, 12, 10, 30, 20, 0, -1, 12, -7, 2, 15,
                               30, 1)),
            'DateTime(2010, 1, 12, 10, 30, 20, 0, -1, 12, -7, 2, 15, 30, 1)')
コード例 #6
0
ファイル: test_pyson.py プロジェクト: silver-dragon/trytond
    def test_Less(self):
        'Test pyson.Less'
        self.assertEqual(
            pyson.Less(0, 1).pyson(), {
                '__class__': 'Less',
                's1': 0,
                's2': 1,
                'e': False,
            })

        if not sys.flags.optimize:
            self.assertRaises(AssertionError, pyson.Less, 'test', 1)
            self.assertRaises(AssertionError, pyson.Less, 0, 'test')
            self.assertRaises(AssertionError, pyson.Less, 'test',
                              pyson.DateTime())
            self.assertRaises(AssertionError, pyson.Less, pyson.DateTime(),
                              'test')

        self.assertEqual(pyson.Less(0, 1).types(), set([bool]))

        eval = pyson.PYSONEncoder().encode(pyson.Less(0, 1))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(1, 0))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(0, 1, True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(1, 0, True))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(1, 1))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(1, 1, True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(None, 1))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Less(1, None))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        self.assertEqual(repr(pyson.Less(0, 1)), 'Less(0, 1, False)')

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                       datetime.date(2020, 1, 1)))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                       datetime.date(2020, 1, 2), True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                       pyson.DateTime(2020, 1, 1, 0, 0, 0, 0)))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.Date(2020, 1, 1), datetime.date(2020, 1, 2)))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.Date(2020, 1, 1),
                       pyson.DateTime(2020, 1, 1, 0, 0, 0, 1)))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                       pyson.Date(2020, 1, 1), True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Less(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0), 90000))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))
コード例 #7
0
ファイル: test_pyson.py プロジェクト: silver-dragon/trytond
    def test_Greater(self):
        'Test pyson.Greater'
        self.assertEqual(
            pyson.Greater(1, 0).pyson(), {
                '__class__': 'Greater',
                's1': 1,
                's2': 0,
                'e': False,
            })

        if not sys.flags.optimize:
            self.assertRaises(AssertionError, pyson.Greater, 'test', 0)
            self.assertRaises(AssertionError, pyson.Greater, 1, 'test')
            self.assertRaises(AssertionError, pyson.Greater, pyson.Eval('foo'),
                              0)
            self.assertRaises(AssertionError, pyson.Greater, 'test',
                              pyson.DateTime())
            self.assertRaises(AssertionError, pyson.Greater, pyson.DateTime(),
                              'test')

        self.assertEqual(pyson.Greater(1, 0).types(), set([bool]))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 0))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(0, 1))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 0, True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(0, 1, True))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 1))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(1, 1, True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(None, 1))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(1, None))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        self.assertEqual(repr(pyson.Greater(1, 0)), 'Greater(1, 0, False)')

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                          datetime.date(2020, 1, 2)))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 0, 1),
                          datetime.date(2020, 1, 1)))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                          datetime.date(2020, 1, 1), True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                          pyson.DateTime(2020, 1, 1, 0, 0, 0, 0)))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.Date(2020, 1, 1), datetime.date(2020, 1, 1)))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.Date(2020, 1, 1),
                          pyson.DateTime(2020, 1, 1, 0, 0, 0, 1)))
        self.assertFalse(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 1),
                          pyson.Date(2020, 1, 1), True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0),
                          pyson.Date(2020, 1, 1), True))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(
            pyson.Greater(pyson.DateTime(2020, 1, 1, 0, 0, 0, 0), 90000))
        self.assertTrue(pyson.PYSONDecoder().decode(eval))

        eval = pyson.PYSONEncoder().encode(pyson.Greater(
            pyson.Eval('i', 0), 0))
        self.assertTrue(pyson.PYSONDecoder({'i': 1}).decode(eval))