if __name__ == '__main__':
    from   os.path import dirname, abspath, join
    import sys
    sys.path.append( abspath( join( dirname(__file__), '..' )))


import os
import unittest
import palm.check

class CheckTests(unittest.TestCase):

    def test_define_check_pass(self):
        def check_bigger_than(max):
            return palm.check.DEFINE_CHECK(
                lambda v,n,c: v is not None and v > max,
                'must be bigger than '+str(max)
                )

        # no excecptins ...
        #
        check_bigger_than(5)( 6 )
        check_bigger_than(5)( 7 )

    def test_define_check_fails(self):
        def check_bigger_than(max):
            return palm.check.DEFINE_CHECK(
                lambda v,n,c: v is not None and v > max,
                'must be bigger than '+str(max)
                )

        with self.assertRaises(AssertionError):
            check_bigger_than(5)( None )
        with self.assertRaises(AssertionError):
            check_bigger_than(5)( 4 )
        with self.assertRaises(AssertionError):
            check_bigger_than(5)( 5 )

        with self.assertRaises(AssertionError) as raised:
            check_bigger_than(10)( 5, 'name' )

        self.assertEqual(
            str(raised.exception),
            '\'name\': \'5\' must be bigger than 10'
            )


    def test_check_never_fails(self):
        # no excecptins ...
        #
        palm.check.CHECK_NEVER_FAILS( None )
        palm.check.CHECK_NOTHING( None )

    def test_check_always_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALLWAYS_FAILS,
            None
            )


    def test_check_not_none_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_NOT_NONE( 'None' )
        palm.check.CHECK_NOT_NONE( [] )
        palm.check.CHECK_NOT_NONE( {} )

    def test_check_not_none_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_NONE,
            None
            )


    def test_check_is_none_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_IS_NONE( None )

    def test_check_is_none_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_NONE,
            ''
            )


    def test_check_not_defined_pass(self):
        palm.check.CHECK_NOT_DEFINED( None )
        palm.check.CHECK_NOT_DEFINED( ''   )
        palm.check.CHECK_NOT_DEFINED( []   )
        palm.check.CHECK_NOT_DEFINED( {}   )

        palm.check.CHECK_IS_EMPTY( None )
        palm.check.CHECK_IS_EMPTY( ''   )
        palm.check.CHECK_IS_EMPTY( []   )
        palm.check.CHECK_IS_EMPTY( {}   )

    def test_check_not_defined_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_DEFINED,
            'None'
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_DEFINED,
            [None]
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_DEFINED,
            {'name':None}
            )

        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_EMPTY,
            'None'
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_EMPTY,
            [None]
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_EMPTY,
            {'name':None}
            )


    def test_check_is_defined_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_IS_DEFINED( 'None'         )
        palm.check.CHECK_IS_DEFINED( [None]         )
        palm.check.CHECK_IS_DEFINED( {'name': None} )

        palm.check.CHECK_NOT_EMPTY( 'None'         )
        palm.check.CHECK_NOT_EMPTY( [None]         )
        palm.check.CHECK_NOT_EMPTY( {'name': None} )

    def test_check_is_defined_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_DEFINED,
            None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_DEFINED,
            ''
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_DEFINED,
            []
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_DEFINED,
            {}
            )

        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_EMPTY,
            None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_EMPTY,
            ''
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_EMPTY,
            []
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_EMPTY,
            {}
            )


    def test_check_is_file_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_IS_FILE( __file__ )

    def test_check_is_file_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_FILE,
            os.path.join( os.path.dirname(__file__) )
            )


    def test_check_is_directory_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_IS_DIRECTORY( os.path.dirname(__file__) )

    def test_check_is_directory_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_DIRECTORY,
            os.path.join( os.path.dirname(__file__), 'unknown'),
            None, None
            )


    def test_check_is_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_IS(int)( 123 )
        palm.check.CHECK_IS(int,float)( 123.456 )

    def test_check_is_fail(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS(int),
            None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS(int),
            '123'
            )


    def test_check_cmp_thr_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_LT(4)(3)

        palm.check.CHECK_LE(4)(3)
        palm.check.CHECK_LE(4)(4)

        palm.check.CHECK_EQ(4)(4)

        palm.check.CHECK_GE(4)(4)
        palm.check.CHECK_GE(4)(5)

        palm.check.CHECK_GT(4)(5)

    def test_check_cmp_thr_fails(self):
        self.assertRaises( AssertionError, palm.check.CHECK_LT(4), 4 )
        self.assertRaises( AssertionError, palm.check.CHECK_LT(4), 5 )

        self.assertRaises( AssertionError, palm.check.CHECK_LE(4), 5 )

        self.assertRaises( AssertionError, palm.check.CHECK_EQ(4), 5 )
        self.assertRaises( AssertionError, palm.check.CHECK_EQ(4), 3 )

        self.assertRaises( AssertionError, palm.check.CHECK_GE(4), 3 )

        self.assertRaises( AssertionError, palm.check.CHECK_GT(4), 3 )
        self.assertRaises( AssertionError, palm.check.CHECK_GT(4), 4 )


    def test_check_regex_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_REGX(r"\d\d:\d\d:\d\d")('12:34:56')
        palm.check.CHECK_REGX(r"\d{2}:\d{2}:\d{2}","hh:mm:ss")('12:34:56', "timestring")

    def test_check_regex_fails(self):
        with self.assertRaises(AssertionError) as raised:
            palm.check.CHECK_REGX(r"\d{2}:\d{2}:\d{2}","hh:mm:ss")('12:34', "timestring"),

        self.assertEqual(
            str(raised.exception),
            "'timestring': '12:34' does not match 'hh:mm:ss'"
            )


    def test_check_is_set_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_IS_SET('name')( None, None, { 'name': 1234 } )

    def test_check_is_set_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_SET('unknown'),
            None, None, { 'name': 1234 }
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_IS_SET('name'),
            None, None, { 'name': None }
            )


    def test_check_not_set_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_NOT_SET('unknown')( None, None, { 'name': 1234 } )
        palm.check.CHECK_NOT_SET('name')( None, None, { 'name': None } )

    def test_check_not_set_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_SET('unknown'),
            None, None, { 'unknown': 1234 }
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_NOT_SET('name'),
            None, None, { 'name': 1234 }
            )


    def test_check_with_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_WITH('name', palm.check.CHECK_EQ(1234))( 4567, 'other', {'name': 1234 })

    def test_check_with_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_WITH(
                'other',
                palm.check.CHECK_EQ(1234)
                ),
            4567, 'other', {'name': 1234 }
            )


    def test_check_all_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_ALL()( None, 'name', None )
        palm.check.CHECK_ALL(
            palm.check.CHECK_NEVER_FAILS
            )( None, 'name', None )
        palm.check.CHECK_ALL(
            palm.check.CHECK_NEVER_FAILS,
            palm.check.CHECK_NEVER_FAILS
            )( None, 'name', None )

    def test_check_all_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALL(
                palm.check.CHECK_ALLWAYS_FAILS
                ),
            None, 'name', None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALL(
                palm.check.CHECK_NEVER_FAILS,
                palm.check.CHECK_ALLWAYS_FAILS
                ),
            None, 'name', None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALL(
                palm.check.CHECK_ALLWAYS_FAILS,
                palm.check.CHECK_NEVER_FAILS
                ),
            None, 'name', None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALL(
                palm.check.CHECK_ALLWAYS_FAILS,
                palm.check.CHECK_ALLWAYS_FAILS
                ),
            None, 'name', None
            )


    def test_check_one_pass(self):
        # no excecptins ...
        #
        palm.check.CHECK_ONE()( None )
        palm.check.CHECK_ONE(
            palm.check.CHECK_NEVER_FAILS
            )( None, 'name', None )
        palm.check.CHECK_ONE(
            palm.check.CHECK_ALLWAYS_FAILS,
            palm.check.CHECK_NEVER_FAILS
            )( None, 'name', None )
        palm.check.CHECK_ONE(
            palm.check.CHECK_NEVER_FAILS,
            palm.check.CHECK_ALLWAYS_FAILS
            )( None, 'name', None )

    def test_check_one_fails(self):
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ONE(
                palm.check.CHECK_ALLWAYS_FAILS
                ),
            None, 'name', None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALL(
                palm.check.CHECK_ALLWAYS_FAILS,
                palm.check.CHECK_ALLWAYS_FAILS
                ),
            None, 'name', None
            )
        self.assertRaises(
            AssertionError,
            palm.check.CHECK_ALL(
                palm.check.CHECK_ALLWAYS_FAILS,
                palm.check.CHECK_ALLWAYS_FAILS,
                palm.check.CHECK_ALLWAYS_FAILS
                ),
            None, 'name', None
            )


if __name__ == '__main__':
    unittest.main()