"""Dimension entity tests."""

from unittest.mock import patch

import pytest

from dim_refresh_etl import dimension


@pytest.fixture(autouse=True)
def dim_config_package(monkeypatch):
    """Patch dimension CONFIG_PACKAGE."""
    monkeypatch.setattr(
        'dim_refresh_etl.dimension.SimpleDimension.CONFIG_PACKAGE',
        'tests.fixtures.dim')


def test_simple_dimension_load():
    """Test dimension entity object."""
    # valid dimension file
    dim = dimension.SimpleDimension('valid_dim')

    # default count sql is generated
    assert dim.insert_count_sql == dim.DEFAULT_INSERT_COUNT_SQL
    assert dim.update_count_sql == dim.DEFAULT_UPDATE_COUNT_SQL

    # default delete sql is used
    assert dim.delete_sql is None

    # default staging table name generated
    assert dim.staging_table == 'staging_dim_artist'

    # invalid dimension files
    with pytest.raises(AssertionError):
        dimension.SimpleDimension('invalid_dim')

    # test dimension mode adds 'test' to dim_table attr
    dim = dimension.SimpleDimension('valid_dim', True)
    assert dim.dim_table == 'dim_artist_test'


@patch.dict(
    'dim_refresh_etl.dimension.SF_CONFIG',
    {'db': 'testdb', 'schema': 'testschema'})
def test_hydrate_query(monkeypatch):
    """Test hydrate_query method."""
    monkeypatch.setenv('SNOWFLAKE_DATABASE', 'testdb')
    monkeypatch.setenv('SNOWFLAKE_SCHEMA', 'testschema')
    expected_sql = (
        'SELECT count(*) '
        'FROM testdb.testschema.dim_artist '
        "WHERE date_created = 'stamp'")
    dim_entity = dimension.SimpleDimension('valid_dim')
    actual_sql = dim_entity.hydrate_query(
        current_timestamp='stamp', sql=dim_entity.insert_count_sql)

    assert actual_sql == expected_sql


@patch.dict(
    'dim_refresh_etl.dimension.SF_CONFIG',
    {'db': 'testdb', 'schema': 'testschema'})
def test_hydrate_query_list():
    """Test hydrate_query_list method."""
    expected_query_list = [
        (
            "INSERT INTO testdb.testschema.dim_artist SELECT 'first', "
            "'stamp', 'stamp' FROM testdb.testschema.staging_dim_artist dat"),
        (
            'INSERT INTO testdb.testschema.dim_artist '
            "SELECT 'second' 'stamp', 'stamp' "
            'FROM testdb.testschema.staging_dim_artist dat')]

    dim_entity = dimension.SimpleDimension('valid_dim')
    actual_query_list = dim_entity.hydrate_query_list(
        current_timestamp='stamp', query_list=dim_entity.insert_sql)

    assert expected_query_list == actual_query_list


def test_create_entity():
    """Test create_entity method."""
    dim_entity = dimension.create_entity('valid_dim')
    assert isinstance(dim_entity, dimension.SimpleDimension)


def test_s3_staging_bucket():
    """Test S3 buckets."""
    bucket = dimension.s3_staging_bucket('prod')
    assert bucket == 'prod-staging-dim-imports'

    bucket = dimension.s3_staging_bucket('dev')
    assert bucket == 'dev-etl-data'

    bucket = dimension.s3_staging_bucket('test')
    assert bucket == 'dev-etl-data'


def test_s3_staging_file():
    """Test s3_staging_file method."""
    staging_file = dimension.s3_staging_file('table')
    assert staging_file == 'table.gz'


def test_s3_staging_key():
    """Test S3 staging key builder."""
    staging_key = dimension.s3_staging_key('table', '1984')
    assert staging_key == 'dim/staging-table/dt=1984/table.gz'


def test_s3_staging_path():
    """Test S3 staging path builder."""
    staging_path = dimension.s3_staging_path('dev', 'table', '1984')
    assert staging_path == 's3://dev-etl-data/dim/staging-table/dt=1984/'


def test_def_staging_table():
    """Test staging_table method."""
    staging_table = dimension.staging_table('table')
    assert staging_table == 'staging_table'