from unittest import TestCase
from mock import Mock, patch

from backend.common.services import BaseService, OperationResult


class KnownError(Exception):
    pass


class UnknownError(Exception):
    pass


def raise_known_error():
    raise KnownError('You should catch me!')


def raise_unknown_error():
    raise UnknownError('You will not catch me!')


class ServiceMock(BaseService):
    known_exceptions = (KnownError)

    def process(self):
        return self.params


class OperationResultTest(TestCase):

    def setUp(self):
        self.service = ServiceMock({ 'foo': 'bar' })
        self.data = self.service.process()

    def test_constructor(self):
        result = OperationResult(data=self.data, source=self.service)

        self.assertEqual(self.data, result.data)
        self.assertEqual(self.service, result.source)
        self.assertEqual(self.service.errors, result.errors)
        self.assertEqual(self.service.failed_objects, result.failed_objects)
        self.assertEqual(self.service.processed, result.processed)

    def test_when_not_processed(self):
        self.service.processed = False
        result = OperationResult(data=self.data, source=self.service)

        self.assertFalse(result.success())
        self.assertTrue(result.fail())

    def test_when_processed_without_errors(self):
        self.service.processed = True
        result = OperationResult(data=self.data, source=self.service)

        self.assertTrue(result.success())
        self.assertFalse(result.fail())
        self.assertFalse(result.source.errors)

    def test_when_processed_with_dict_errors(self):
        self.service.processed = True
        self.service.errors = { 'foo' : 'foo is not bar' }
        result = OperationResult(data=self.data, source=self.service)

        self.assertFalse(result.success())
        self.assertTrue(result.fail())
        self.assertTrue(result.source.errors)

    def test_when_processed_with_list_errors(self):
        self.service.processed = True
        self.service.errors = ['foo is not bar']
        result = OperationResult(data=self.data, source=self.service)

        self.assertFalse(result.success())
        self.assertTrue(result.fail())
        self.assertTrue(result.source.errors)


class BaseServiceTest(TestCase):

    def setUp(self):
        self.service = ServiceMock(
            params={ 'foo': 'bar' },
            foo_required=True,
            bar_allowed=False
        )

    def test_constructor(self):
        self.assertEqual(None, self.service.raw_result)
        self.assertEqual(None, self.service.errors)
        self.assertEqual([], self.service.failed_objects)
        self.assertEqual('bar', self.service.params['foo'])

        self.assertFalse(self.service.processed)
        self.assertFalse(self.service.bar_allowed)
        self.assertTrue(self.service.foo_required)

    @patch('backend.common.tests.tests_services.ServiceMock.execute', Mock())
    def test_do_execute_call(self):
        ServiceMock.do_execute({ 'foo': 'bar' })
        ServiceMock.execute.assert_called_with()

    def test_do_process_return(self):
        result = ServiceMock.do_execute({ 'foo': 'bar' })
        self.assertIsInstance(result, OperationResult)

    @patch('backend.common.tests.tests_services.ServiceMock.process', Mock())
    def test_do_process_call(self):
        ServiceMock.do_process({ 'foo': 'bar' })
        ServiceMock.process.assert_called_with()

    def test_do_process_return(self):
        result = ServiceMock.do_process({ 'foo': 'bar' })
        self.assertIsNotNone(result)

    @patch('backend.common.tests.tests_services.ServiceMock.process', Mock())
    def test_process_call(self):
        ServiceMock().execute()
        ServiceMock.process.assert_called_with()

    def test_operation_result(self):
        result = self.service.execute()
        self.assertIsInstance(result, OperationResult)

    def test_processed(self):
        self.assertFalse(self.service.processed)
        self.service.execute()
        self.assertTrue(self.service.processed)


class BaseServiceWithErrorsTest(TestCase):

    def setUp(self):
        self.service = ServiceMock(params={ 'foo': 'bar' })

    @patch('backend.common.tests.tests_services.ServiceMock.process', side_effect=raise_known_error)
    def test_execute_with_known_exceptions(self, _process):
        result = self.service.execute()
        self.assertFalse(result.success())
        self.assertEqual('You should catch me!', result.errors[0])
        self.assertIsInstance(result.failed_objects[0], KnownError)


    @patch('backend.common.tests.tests_services.ServiceMock.process', side_effect=raise_unknown_error)
    def test_execute_with_unknown_exceptions(self, _process):
        self.assertRaises(UnknownError, self.service.execute)
        self.assertTrue(self.service.processed)
        self.assertIsNone(self.service.errors)
        self.assertIsNone(self.service.raw_result)
        self.assertEqual([], self.service.failed_objects)

    @patch('backend.common.tests.tests_services.ServiceMock.process', side_effect=raise_known_error)
    def test_process_with_known_exceptions(self, _process):
        self.assertRaises(KnownError, self.service.process)
        self.assertFalse(self.service.processed)
        self.assertIsNone(self.service.errors)
        self.assertIsNone(self.service.raw_result)
        self.assertEqual([], self.service.failed_objects)

    @patch('backend.common.tests.tests_services.ServiceMock.process', side_effect=raise_unknown_error)
    def test_process_with_unknown_exceptions(self, _process):
        self.assertRaises(UnknownError, self.service.process)
        self.assertFalse(self.service.processed)
        self.assertIsNone(self.service.errors)
        self.assertIsNone(self.service.raw_result)
        self.assertEqual([], self.service.failed_objects)