from hypothesis import given
import hypothesis.strategies as st
import sqlalchemy
import unittest

from fpsweeper.connector import mysql
from fpsweeper.context import context
from fpsweeper.logic import util


class TestSweeperUtilityFunctions(unittest.TestCase):
    """Test utility functions
    """
    def setUp(self):
        context.reset()  # always reset
        context.set('correlation_id', util.create_correlation_id())

    def tearDown(self):
        context.reset()

    @given(sublist_size=st.integers(min_value=1))
    def test_yield_sublists_empty_list(self, sublist_size):
        """Assert that passing in an empty list returns an empty list
        """

        arg_list = []
        res = util.yield_sublists(arg_list, sublist_size)
        self.assertEqual(len(list(res)), 0)

    def test_yield_sublists_divisible(self):
        """Assert that passing in a list of 6 items with sublist_size of 2 returns 3 sublists of equal size.
        """

        arg_list = [x for x in range(0, 6)]
        sublist_size = 2
        res = util.yield_sublists(arg_list, sublist_size)
        res = list(res)
        self.assertEqual(len(res), 3)
        self.assertListEqual(res, [[0, 1], [2, 3], [4, 5]])

    def test_yield_sublists_remainder(self):
        """Assert that passing in a list of 6 items with sublist_size of 4 returns 2 sublists of unequal size.
        """

        arg_list = [x for x in range(0, 6)]
        sublist_size = 4
        res = util.yield_sublists(arg_list, sublist_size)
        res = list(res)
        self.assertEqual(len(res), 2)
        self.assertListEqual(res, [[0, 1, 2, 3], [4, 5]])

    @given(arg_list=st.lists(elements=st.integers(), min_size=1))
    def test_yield_sublists_single_item(self, arg_list):
        """Assert that passing in a list of n items with sublist_size of 1 returns n sublists
        """

        sublist_size = 1
        res = util.yield_sublists(arg_list, sublist_size)
        res = list(res)
        self.assertEqual(len(res), len(arg_list))
        expected_res = [[n] for n in arg_list]
        self.assertListEqual(res, expected_res)

    @given(arg_list=st.lists(elements=st.integers(), min_size=1))
    def test_yield_sublists_arg_greater_than_length(self, arg_list):
        """Assert that passing in a list of n items with sublist_size > n returns single sublist of n items
        """

        sublist_size = len(arg_list) + 1
        res = util.yield_sublists(arg_list, sublist_size)
        res = list(res)
        self.assertEqual(len(res), 1)
        self.assertListEqual(res, [arg_list])

    def test_try_execute_query_null_db_session(self):
        """Assert that try_execute_query raises exception if null db_session passed in
        """
        with self.assertRaises(AttributeError):
            util.try_execute_query(db_session=None, clause=None)

    def test_try_execute_query_null_sql(self):
        """Assert that try_execute_query raises exception if null sql is passed in
        """
        test_db_session = mysql.fpc_session()
        with self.assertRaises(sqlalchemy.exc.StatementError):
            util.try_execute_query(db_session=test_db_session, clause=None)

    def test_try_execute_query_bad_sql(self):
        """Assert that try_execute_query raises exception if bad sql is passed in
        """
        test_db_session = mysql.fpc_session()
        with self.assertRaises(sqlalchemy.exc.OperationalError):
            util.try_execute_query(db_session=test_db_session, clause="bad sql")

    def test_try_execute_query_nonexistent_table(self):
        """Assert that try_execute_query raises exception trying to query non-existent table
        """
        test_db_session = mysql.fpc_session()
        with self.assertRaises(sqlalchemy.exc.OperationalError):
            clause = "select * from hbtcpaoucz where 1=0"
            util.try_execute_query(db_session=test_db_session, clause=clause)