"""Unit tests for workflow activities."""

from unittest.mock import MagicMock

from garcon.activity import Activity
import pytest

from snowflake_views.flow import Flow


class TestFlow(object):
    """Tests for Flow."""

    @pytest.fixture
    def flow(self):
        """Create flow."""
        return Flow()

    @pytest.fixture
    def mock_schedule_do_not_rebuild(self, mock_schedule):
        """Mock schedule for not rebuilding view."""
        mock_schedule.return_value = MagicMock(
            result={'check_dynamo_status.rebuild_view': False})
        return mock_schedule

    @pytest.fixture
    def run_flow(self, flow, mock_schedule, mock_context):
        """Run flow."""
        flow.decider(mock_schedule, mock_context)

    @pytest.fixture
    def run_flow_do_not_rebuild(
            self, flow, mock_schedule_do_not_rebuild, mock_context):
        """Run flow without rebuilding view."""
        flow.decider(mock_schedule_do_not_rebuild, mock_context)

    def test_decider_first_schedules_activity_called_check_dynamo_status(
            self, mock_schedule, run_flow):
        """Test decider schedules activity called check_dynamo_status."""
        (name, _), _ = mock_schedule.call_args_list[0]
        assert name == 'check_dynamo_status'

    def test_decider_schedules_activity_called_create_view(
            self, mock_schedule, run_flow):
        """Test decider schedules activity called create_view."""
        (name, _), _ = mock_schedule.call_args_list[1]
        assert name == 'create_view'

    def test_decider_schedules_activity_called_cache_view(
            self, mock_schedule, run_flow):
        """Test decider schedules activity called cache_view."""
        (name, _), _ = mock_schedule.call_args_list[2]
        assert name == 'cache_view'

    def test_decider_schedules_activity_called_save_last_processed_timestamp(
            self, mock_schedule, run_flow):
        """Test decider schedules activity save_last_processed_timestamp."""
        (name, _), _ = mock_schedule.call_args_list[3]
        assert name == 'save_last_processed_timestamp'

    def test_decider_schedules_check_dynamo_status_with_activity_object(
            self, mock_schedule, run_flow):
        """Test decider schedules check_dynamo_status with activity object."""
        (_, activity), _ = mock_schedule.call_args_list[0]
        assert isinstance(activity, Activity)

    def test_decider_schedules_create_view_with_activity_object(
            self, mock_schedule, run_flow):
        """Test decider schedules create_view with activity object."""
        (_, activity), _ = mock_schedule.call_args_list[1]
        assert isinstance(activity, Activity)

    def test_decider_schedules_cache_view_with_activity_object(
            self, mock_schedule, run_flow):
        """Test decider schedules cache_view with activity object."""
        (_, activity), _ = mock_schedule.call_args_list[2]
        assert isinstance(activity, Activity)

    def test_decider_schedules_last_processed_timestamp_with_activity_object(
            self, mock_schedule, run_flow):
        """Test decider schedules last_processed_timestamp."""
        (_, activity), _ = mock_schedule.call_args_list[3]
        assert isinstance(activity, Activity)

    def test_decider_schedules_check_dynamo_status_with_correct_task(
            self, mock_schedule, run_flow):
        """Test decider schedules check_dynamo_status with correct task."""
        (_, activity), _ = mock_schedule.call_args_list[0]
        assert activity.runner.tasks[0].__name__ == 'check_dynamo_status'

    def test_decider_schedules_create_view_with_correct_task(
            self, mock_schedule, run_flow):
        """Test decider schedules create_view with correct task."""
        (_, activity), _ = mock_schedule.call_args_list[1]
        assert activity.runner.tasks[0].__name__ == 'create_view'

    def test_decider_schedules_cache_view_with_correct_task(
            self, mock_schedule, run_flow):
        """Test decider schedules cache_view with correct task."""
        (_, activity), _ = mock_schedule.call_args_list[2]
        assert activity.runner.tasks[0].__name__ == 'cache_view'

    def test_decider_schedules_last_processed_timestamp_with_correct_task(
            self, mock_schedule, run_flow):
        """Test decider schedules save_last_processed_timestamp."""
        (_, activity), _ = mock_schedule.call_args_list[3]
        assert activity.runner.tasks[0].__name__ == \
            'save_last_processed_timestamp'

    def test_decider_stops_after_check_dynamo_status(
            self, mock_schedule_do_not_rebuild, run_flow_do_not_rebuild):
        """Test decider stops after check_dynamo_status."""
        assert mock_schedule_do_not_rebuild.call_count == 1

    def test_workflow_id_contains_view_name(self, flow, mock_context):
        """Test workflow_id contains view name."""
        workflow_id = flow.workflow_id(mock_context)
        assert workflow_id == '{flow_name}-{view_name}'.format(
            flow_name=flow.name, view_name=mock_context['name'])