"""Unit tests for fact_analytics generic Snowflake SQL executor."""

from unittest.mock import MagicMock
from unittest.mock import patch

import pytest
from snowflake import connector

from feed_ingestion.common.fact_analytics_sf.base_executor \
    import SnowflakeSQLExecutorFA


def feed_name(self):
    """Return value to mock the property."""
    return 'deezer_sf'


def feedid(self):
    """Return value to mock the property."""
    return 0


def feed_name_for_uuid(self):
    """Return value to mock the property."""
    return 'Deezer'


def storeid(self):
    """Return value to mock the property."""
    return 0


def staging_raw_table(self):
    """Return value to mock the property."""
    return 'staging_raw_deezer_sf'


@pytest.fixture
def executor_mock(monkeypatch):
    """Set properties."""
    monkeypatch.setattr(
        SnowflakeSQLExecutorFA, 'feed_name', property(feed_name))
    monkeypatch.setattr(
        SnowflakeSQLExecutorFA, 'storeid', property(storeid))
    monkeypatch.setattr(
        SnowflakeSQLExecutorFA, 'feedid', property(feedid))
    monkeypatch.setattr(
        SnowflakeSQLExecutorFA, 'staging_raw_table',
        property(staging_raw_table))
    return SnowflakeSQLExecutorFA


@pytest.fixture(autouse=True)
def sf_execute_mock(monkeypatch):
    """Yield execute."""
    with MagicMock() as connect_mock:
        monkeypatch.setattr(connector, 'connect', connect_mock)
        yield connect_mock.return_value.cursor.return_value.execute


def test_notimplemented_properties(sf_config_mock):
    """Test properties to be implemented in feed specific executors."""
    with pytest.raises(NotImplementedError):
        SnowflakeSQLExecutorFA(sf_config_mock).feed_name
    with pytest.raises(NotImplementedError):
        SnowflakeSQLExecutorFA(sf_config_mock).storeid
    with pytest.raises(NotImplementedError):
        SnowflakeSQLExecutorFA(sf_config_mock).staging_raw_table


def test_notimplemented_methods(sf_config_mock):
    """Test not implemented methods."""
    with pytest.raises(NotImplementedError):
        SnowflakeSQLExecutorFA(
            sf_config_mock).load_staging_fact_table('2017-08-02')

    with pytest.raises(NotImplementedError):
        SnowflakeSQLExecutorFA(
            sf_config_mock).load_fact_error_data('2017-08-02')


def test_fact_tables_properties(sf_config_mock):
    """Test fact tables names properties."""
    assert (
        SnowflakeSQLExecutorFA(sf_config_mock).fact_table == 'fact_analytics')
    assert (
        SnowflakeSQLExecutorFA(sf_config_mock).fact_error_table ==
        'fact_analytics_error')


def test_staging_fact_table(monkeypatch, sf_config_mock):
    """Test staging_fact_table returning parametrized table name."""
    with pytest.raises(NotImplementedError):
        SnowflakeSQLExecutorFA(sf_config_mock).staging_fact_table('2017-08-02')
    monkeypatch.setattr(
        SnowflakeSQLExecutorFA, 'feed_name', property(feed_name))
    SnowflakeSQLExecutorFA(sf_config_mock)
    assert (SnowflakeSQLExecutorFA(sf_config_mock).staging_fact_table(
        '2017-08-02') == 'staging_fact_analytics_deezer_sf_20170802')


def test_create_staging_fact_table(sf_config_mock, executor_mock):
    """Test create_staging_fact_table method."""
    create_table_like_mock = MagicMock()
    executor_object = executor_mock(sf_config_mock)

    with patch.multiple(
        executor_object,
        create_table_like=create_table_like_mock,
        staging_fact_table=MagicMock(
            return_value='staging_fact_table')):
        executor_object.create_staging_fact_table('2017-08-02')

        create_table_like_mock.assert_called_once_with(
            'staging_fact_table',
            source_table='fact_analytics',
            source_db=sf_config_mock.get('db'),
            source_schema=sf_config_mock.get('schema'),
            transient=True)


def test__delete_from_fact_table(
        sf_config_mock, executor_mock, sf_execute_mock):
    """Test _delete_from_fact_table method."""
    SnowflakeSQLExecutorFA(
        sf_config_mock)._delete_from_fact_table(
        'fact_analytics', '2017-08-02')
    assert sf_execute_mock.call_count == 1


def test_delete_from_fact_table(
        sf_config_mock, executor_mock, sf_execute_mock):
    """Test delete_from_fact_table method."""
    SnowflakeSQLExecutorFA(
        sf_config_mock).delete_from_fact_table('2017-08-02')
    assert sf_execute_mock.call_count == 1


def test_delete_from_fact_error_table(
        sf_config_mock, executor_mock, sf_execute_mock):
    """Test delete_from_fact_error_table method."""
    SnowflakeSQLExecutorFA(
        sf_config_mock).delete_from_fact_error_table('2017-08-02')
    assert sf_execute_mock.call_count == 1


def test_load_fact_data_v2(sf_config_mock, executor_mock, sf_execute_mock):
    """Test load_fact_data_v2 method."""
    SnowflakeSQLExecutorFA(sf_config_mock).load_fact_data('2017-08-02')

    assert sf_execute_mock.call_count == 1