#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
@Version: 1.0
@Python Version:3.6.6
@Author: wenhx8
@File: test_utility
@Time: 2019/1/7 007 22:01
@Description: 测试代码
"""
import os
from datetime import datetime
from unittest import TestCase, main

from cucc_common_pkg.globalutility import Utility, GlobalConst, DateTimeConst
from cucc_common_pkg.my_stringutils import MyStringUtils


class TestUtility(TestCase):
    r'''
    TestUtility
    '''

    def test_format_result(self):
        r'''

        Returns:

        '''
        ret = Utility.format_result('success', '1')
        self.assertEqual(ret, Utility.format_success('success'))

    def test_format_error(self):
        r'''

        Returns:

        '''
        ret = Utility.format_error('error')
        self.assertEqual(ret, Utility.format_result('error', GlobalConst.RETCODE_COMMON_ERROR))

    def test_format_success(self):
        r'''

        Returns:

        '''
        ret = Utility.format_success('success')
        self.assertEqual(ret, Utility.format_result('success', GlobalConst.RETCODE_SUCESS_CODE))

    def test_dict2jsonstr(self):
        r'''

        Returns:

        '''
        a_dict = {'a': 1, 'b': 'xx'}
        json_str = '{"a": 1, "b": "xx"}'
        ret = Utility.dict2jsonstr(a_dict)
        self.assertEqual(ret, json_str)

        a_dict = None
        json_str = 'null'
        ret = Utility.dict2jsonstr(a_dict)
        self.assertEqual(ret, json_str)

        a_dict = None
        json_str = ''
        ret = Utility.dict2jsonstr(a_dict, value_when_obj_is_none='')
        self.assertEqual(ret, json_str)

    def test_list2jsonstr(self):
        r'''

        Returns:

        '''
        a_list = ['a', 'b', 'c']
        json_str = '["a", "b", "c"]'
        ret = Utility.list2jsonstr(a_list)
        self.assertEqual(ret, json_str)

        a_tuple = ('a', 'b', 'c')
        json_str = '["a", "b", "c"]'
        ret = Utility.list2jsonstr(a_tuple)
        self.assertEqual(ret, json_str)

        a_dict = None
        json_str = 'null'
        ret = Utility.list2jsonstr(a_dict)
        self.assertEqual(ret, json_str)

        a_dict = None
        json_str = ''
        ret = Utility.list2jsonstr(a_dict, value_when_obj_is_none='')
        self.assertEqual(ret, json_str)

    def test_jsonstr2dict(self):
        r'''

        Returns:

        '''
        json_str = '{"a": 1, "b": "xx"}'
        a_dict = {'a': 1, 'b': 'xx'}
        ret = Utility.jsonstr2dict(json_str)
        self.assertEqual(ret, a_dict)

        json_str = {}
        a_dict = {}
        ret = Utility.jsonstr2dict(json_str)
        self.assertEqual(ret, a_dict)

        json_str = 'abc'
        with self.assertRaises(Exception):
            Utility.jsonstr2dict(json_str, b_raise_error_when_illegal=True)

        json_str = '[1,2,3]'
        with self.assertRaises(Exception):
            Utility.jsonstr2dict(json_str, b_raise_error_when_illegal=True)

    def test_jsonstr2list(self):
        r'''

        Returns:

        '''
        json_str = '[1,2,3]'
        a_list = [1, 2, 3]
        ret = Utility.jsonstr2list(json_str)
        self.assertEqual(ret, a_list)

        json_str = []
        a_list = []
        ret = Utility.jsonstr2list(json_str)
        self.assertEqual(ret, a_list)

        json_str = 'abc'
        with self.assertRaises(Exception):
            Utility.jsonstr2list(json_str, b_raise_error_when_illegal=True)

        json_str = '{"a":1}'
        with self.assertRaises(Exception):
            Utility.jsonstr2list(json_str, b_raise_error_when_illegal=True)

    def test_dofilterxss(self):
        r'''

        Returns:

        '''
        to_filter_str = '<script></script>'
        expect_str = '#《#script#》##《#/script#》#'
        filteredstr = Utility.do_filter_xss(to_filter_str)
        self.assertEqual(expect_str, filteredstr)

    def test_now_day(self):
        r'''

        Returns:

        '''
        a_date = datetime.now()
        expect_str = a_date.strftime(DateTimeConst.COMMON_DATE_FORMAT)
        ret_str = Utility.now_day(a_date=a_date)
        self.assertEqual(expect_str, ret_str)

        a_date = datetime.now()
        expect_str = a_date.strftime(DateTimeConst.COMMON_DATETIME_FORMAT)
        ret_str = Utility.now_daytime(a_date=a_date)
        self.assertEqual(expect_str, ret_str)

        a_date = datetime.now()
        expect_str = a_date.strftime('%Y/%m/%d %H:%M:%S')
        ret_str = Utility.now_daytime(a_date=a_date, format_str='%Y/%m/%d %H:%M:%S')
        self.assertEqual(expect_str, ret_str)

    def test_parse_datestr(self):
        r'''

        Returns:

        '''
        date_str = '2012-03-05 16:26:23'
        pattern_str = '%Y-%m-%d %H:%M:%S'
        a_datetime = datetime(year=2012, month=3, day=5, hour=16, minute=26, second=23)
        self.assertEqual(a_datetime, Utility.parse_datestr(date_str, pattern_str))

        date_str = '2012-03-05 16:26:23'
        a_datetime = datetime(year=2012, month=3, day=5, hour=16, minute=26, second=23)
        self.assertEqual(a_datetime, Utility.parse_datestr(date_str))

        date_str = '2012-03-05'
        a_datetime = datetime(year=2012, month=3, day=5)
        self.assertEqual(a_datetime, Utility.parse_datestr(date_str))

    def test_check_param_equal(self):
        r'''

        Returns:

        '''
        Utility.check_param_equal('a', 'a', 'errmsg')

        with self.assertRaises(Exception):
            Utility.check_param_equal(None, 'b', 'errmsg')

        Utility.check_param_bool(True, 'errmsg')

        with self.assertRaises(Exception):
            Utility.check_param_bool({}, 'errmsg')

        Utility.check_param_none_or_empty('a', 'errmsg')

        with self.assertRaises(Exception):
            Utility.check_param_none_or_empty(None, 'errmsg')

        with self.assertRaises(Exception):
            Utility.check_param_none_or_empty('   ', 'errmsg', trim=True)

        a_dict = Utility.check_param_jsonstr('{"a":"你好"}', 'errmsg')
        self.assertEqual(a_dict['a'], '你好')

        with self.assertRaises(Exception):
            Utility.check_param_jsonstr(None, 'errmsg')

    def test_do_filter_mysql_param(self):
        r'''

        Returns:

        '''
        to_filtered_str = "\\\'123\\\'"
        expect_str = "'\\\\\\\'123\\\\\\\''"
        self.assertEqual(expect_str, Utility.do_filter_mysql_param(to_filtered_str))

        to_filtered_str = "\\`aaa\\`"
        expect_str = "`\\\\\\`aaa\\\\\\``"
        self.assertEqual(expect_str, Utility.do_filter_mysql_field(to_filtered_str))

    def test_is_hasxss(self):
        r'''

        Returns:

        '''
        to_check_str = "%3C%3D%3B"
        self.assertEqual(Utility.is_hasxss(to_check_str), '存在违规数据:encodestrictscript')

        to_check_str = "<script>aa</script>"
        self.assertEqual(Utility.is_hasxss(to_check_str), '存在违规数据:script')

    def test_list_join_to_str(self):
        r'''

        Returns:

        '''

        a_list = [1, 2, 3, 4]
        expect_str = "1,2,3,4"
        a_str = Utility.list_join_to_str(a_list)
        self.assertEqual(a_str, expect_str)

        a_list = []
        expect_str = ""
        a_str = Utility.list_join_to_str(a_list, wrapper_str="'")
        self.assertEqual(a_str, expect_str)

        a_list = [1, 2, 3, 4]
        expect_str = "1##2##3##4"
        a_str = Utility.list_join_to_str(a_list, wrapper_str=None, separator_str='##')
        self.assertEqual(a_str, expect_str)

        a_list = [1, None, 3, None, 5]
        expect_str = "1,3,5"
        a_str = Utility.list_join_to_str(a_list)
        self.assertEqual(a_str, expect_str)

        a_list = [1, None, 3, None, 5]
        expect_str = "'1',null,'3',null,'5'"
        a_str = Utility.list_join_to_str(a_list, ignore_none=False, wrapper_str="'")
        self.assertEqual(a_str, expect_str)

        expect_str = "1234"
        a_str = Utility.join_str(1, 2, 3, 4)
        self.assertEqual(a_str, expect_str)

        expect_str = "1##2##3##4"
        a_str = Utility.join_str(1, 2, 3, 4, wrapper_str=None, separator_str='##')
        self.assertEqual(a_str, expect_str)

        expect_str = "135"
        a_str = Utility.join_str(1, None, 3, None, 5)
        self.assertEqual(a_str, expect_str)

        expect_str = "'1'null'3'null'5'"
        a_str = Utility.join_str(1, None, 3, None, 5, ignore_none=False, wrapper_str="'")
        self.assertEqual(a_str, expect_str)

    def test_create_uuid(self):
        r'''

        Returns:

        '''
        a_str = Utility.create_uuid()
        a_str2 = Utility.create_uuid()
        self.assertNotEqual(a_str, a_str2)

    def test_check_url_illegal(self):
        r'''

        Returns:

        '''
        self.assertTrue(Utility.check_url_illegal('http://a.com'))
        self.assertTrue(Utility.check_url_illegal('http://a.com/'))
        self.assertFalse(Utility.check_url_illegal('a.com/'))

    def test_filter_utf8mb4(self):
        r'''

        Returns:

        '''
        a_str = '你好😜我好'
        expect_str = '你好我好'
        self.assertTrue(Utility.filter_utf8mb4(a_str), expect_str)

        self.assertEqual(Utility.find_utf8mb4(a_str), '😜')
        self.assertEqual(Utility.find_utf8mb4(expect_str), MyStringUtils.EMPTY)

    def test_do_check_and_put_param(self):
        r'''

        Returns:

        '''
        arg_dict = {}
        param_dict = {
            'a': '',
            'b': None,
            'c': '1',
            'd': 2
        }
        expect_dict = {
            'c': '1',
            'd': '2'
        }
        self.assertEqual(Utility.do_check_and_put_param(arg_dict, param_dict, 0), expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '',
            'b': 'xx',
            'c': '1',
            'd': 2
        }
        with self.assertRaises(Exception):
            Utility.do_check_and_put_param(arg_dict, param_dict, 0)

        arg_dict = {}
        param_dict = {
            'a': '1e3',
            'b': 2e-1,
            'c': '1',
            'd': 2.3,
            'e': ''
        }
        expect_dict = {
            'a': '1000.0',
            'b': '0.2',
            'c': '1.0',
            'd': '2.3'
        }
        self.assertEqual(Utility.do_check_and_put_param(arg_dict, param_dict, 1), expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '',
            'b': 'xx',
            'c': '1',
            'd': 2
        }
        with self.assertRaises(Exception):
            Utility.do_check_and_put_param(arg_dict, param_dict, 1)

        arg_dict = {}
        param_dict = {
            'a': '2019-1-1',
            'b': datetime(year=2019, month=1, day=1),
            'c': '2019-1-1 11:00:11',
            'd': '2019/1/1',
            'e': ''
        }
        expect_dict = {
            'a': '2019-01-01 00:00:00',
            'b': '2019-01-01 00:00:00',
            'c': '2019-01-01 11:00:11',
            'd': '2019-01-01 00:00:00'
        }
        self.assertEqual(Utility.do_check_and_put_param(arg_dict, param_dict, 2), expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '2019-1-1 1:23:111',
            'b': datetime(year=2019, month=1, day=1),
            'c': '2019-1-1 11:00:11',
            'd': '2019/1/1',
            'e': ''
        }
        with self.assertRaises(Exception):
            Utility.do_check_and_put_param(arg_dict, param_dict, 2)

        arg_dict = {}
        param_dict = {
            'a': '2019-1-1',
            'b': datetime(year=2019, month=1, day=1),
            'c': '2019-1-1 11:00:11',
            'd': '2019/1/1',
            'e': ''
        }
        with self.assertRaises(ValueError):
            Utility.do_check_and_put_param(arg_dict, param_dict, 3)

    def test_do_check_and_put_param_for_not_none_or_empty(self):
        r'''

        Returns:

        '''
        arg_dict = {}
        param_dict = {
            'a': '',
            'b': None,
            'c': '1',
            'd': 2
        }
        expect_dict = {
            'c': '1',
            'd': '2'
        }
        self.assertEqual(Utility.do_check_and_put_param_for_not_none_or_empty(arg_dict, param_dict), expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '',
            'b': None,
            'c': '1',
            'd': 2
        }
        expect_dict = {
            'a': '',
            'c': '1',
            'd': '2'
        }
        self.assertEqual(Utility.do_check_and_put_param_for_not_none_or_empty(arg_dict, param_dict, ignore_empty=False),
                         expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '',
            'b': None,
            'c': '1',
            'd': 2
        }
        expect_dict = {
            'a': '',
            'b': 'null',
            'c': '1',
            'd': '2'
        }
        self.assertEqual(Utility.do_check_and_put_param_for_not_none_or_empty(arg_dict, param_dict, ignore_empty=False,
                                                                              ignore_none=False),
                         expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '',
            'b': 'xx',
            'c': '1',
            'd': 2
        }
        expect_dict = {
            'b': 'xx',
            'c': '1',
            'd': '2'
        }
        self.assertEqual(Utility.do_check_and_put_param_for_not_none_or_empty(arg_dict, param_dict), expect_dict)

        arg_dict = {}
        param_dict = {
            'a': '1e3',
            'b': 2e-1,
            'c': '1',
            'd': 2.3,
            'e': ''
        }
        expect_dict = {
            'a': '1e3',
            'b': '0.2',
            'c': '1',
            'd': '2.3'
        }
        self.assertEqual(Utility.do_check_and_put_param_for_not_none_or_empty(arg_dict, param_dict), expect_dict)

        arg_dict = {}
        param_dict = {
            'b': datetime(year=2019, month=1, day=1),
        }
        expect_dict = {
            'b': '2019-01-01 00:00:00',
        }
        self.assertEqual(Utility.do_check_and_put_param_for_not_none_or_empty(arg_dict, param_dict), expect_dict)

    def test_get_env(self):
        r'''

        Returns:

        '''
        env_name = 'TEST_ENVNAME'
        env_value = 'TEST_ENVVALUE'
        os.environ[env_name] = env_value
        self.assertEqual(Utility.get_env(env_name), env_value)


if __name__ == '__main__':
    main()