"""Tests for datastore module."""

from unittest.mock import Mock
from unittest.mock import patch

from flows import datastore


@patch('flows.datastore.MySQLdb')
def test__connection(mysql):
    """Test _connection function."""
    connection_object = Mock()
    mysql.connect.return_value = connection_object
    result = datastore._connection()
    assert result == connection_object


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_context(_connection, database):
    """Test context function."""
    conn = Mock()
    _connection.return_value = conn

    datastore.context()
    assert _connection.called
    database.context.assert_called_once_with(conn)


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_context_with_args(_connection, database):
    """Test context function with args."""
    conn = Mock()
    arg = 'foo'
    _connection.return_value = conn

    datastore.context(arg, foo='bar')
    assert _connection.called
    database.context.assert_called_once_with(conn, arg, foo='bar')


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_execute(_connection, database):
    """Test execute function."""
    conn = Mock()
    params = Mock()
    sql = Mock()

    _connection.return_value = conn

    datastore.execute(sql, params)
    assert _connection.called
    database.execute.assert_called_once_with(conn, sql, params)


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_execute_with_args(_connection, database):
    """Test execute function."""
    conn = Mock()
    params = Mock()
    sql = Mock()
    arg = 'hello world'

    _connection.return_value = conn

    datastore.execute(sql, params, arg, foo='bar')
    assert _connection.called
    database.execute.assert_called_once_with(conn, sql, params, arg, foo='bar')


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_executemany(_connection, database):
    """Test executemany function."""
    conn = Mock()
    sequence = Mock()
    sql = Mock()

    _connection.return_value = conn

    datastore.executemany(sql, sequence)
    assert _connection.called
    database.executemany.assert_called_once_with(conn, sql, sequence)


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_executemany_with_args(_connection, database):
    """Test executemany function."""
    conn = Mock()
    sequence = Mock()
    sql = Mock()
    arg = 'hello world'

    _connection.return_value = conn

    datastore.executemany(sql, sequence, arg, foo='bar')
    assert _connection.called
    database.executemany.assert_called_once_with(
      conn, sql, sequence, arg, foo='bar')


@patch('flows.datastore.database')
@patch('flows.datastore._connection')
def test_query(_connection, database):
    """Test query function."""
    conn = Mock()
    params = Mock()
    sql = Mock()
    arg = 'hello world'

    _connection.return_value = conn

    datastore.query(sql, params, arg, foo='bar')
    assert _connection.called
    database.query.assert_called_once_with(conn, sql, params, arg, foo='bar')