<commit_before># -*- coding: utf-8 -*-
"""
    :codeauthor: <NAME> <<EMAIL>>
"""
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals

import os

# Import Salt Libs
import salt.states.mysql_query as mysql_query

# Import Salt Testing Libs
from tests.support.mixins import LoaderModuleMockMixin
from tests.support.mock import MagicMock, patch
from tests.support.unit import TestCase


class MysqlQueryTestCase(TestCase, LoaderModuleMockMixin):
    """
    Test cases for salt.states.mysql_query
    """

    def setup_loader_modules(self):
        return {mysql_query: {}}

    # 'run' function tests: 1

    def test_run(self):
        """
        Test to execute an arbitrary query on the specified database.
        """
        name = "query_id"
        database = "my_database"
        query = "SELECT * FROM table;"

        ret = {"name": name, "result": True, "comment": "", "changes": {}}

        mock_t = MagicMock(return_value=True)
        mock_f = MagicMock(return_value=False)
        mock_str = MagicMock(return_value="salt")
        mock_none = MagicMock(return_value=None)
        mock_dict = MagicMock(return_value={"salt": "SALT"})
        mock_lst = MagicMock(return_value=["grain"])
        with patch.dict(mysql_query.__salt__, {"mysql.db_exists": mock_f}):
            with patch.object(mysql_query, "_get_mysql_error", mock_str):
                ret.update({"comment": "salt", "result": False})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

            with patch.object(mysql_query, "_get_mysql_error", mock_none):
                comt = "Database {0} is not present".format(name)
                ret.update({"comment": comt, "result": None})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

        with patch.dict(
            mysql_query.__salt__,
            {
                "mysql.db_exists": mock_t,
                "grains.ls": mock_lst,
                "grains.get": mock_dict,
                "mysql.query": mock_str,
            },
        ):
            comt = "No execution needed. Grain grain already set"
            ret.update({"comment": comt, "result": True})
            self.assertDictEqual(
                mysql_query.run(
                    name,
                    database,
                    query,
                    output="grain",
                    grain="grain",
                    overwrite=False,
                ),
                ret,
            )

            with patch.dict(mysql_query.__opts__, {"test": True}):
                comt = "Query would execute, storing result in grain: grain"
                ret.update({"comment": comt, "result": None})
                self.assertDictEqual(
                    mysql_query.run(
                        name, database, query, output="grain", grain="grain"
                    ),
                    ret,
                )

                comt = "Query would execute, storing result" " in grain: grain:salt"
                ret.update({"comment": comt})
                self.assertDictEqual(
                    mysql_query.run(
                        name, database, query, output="grain", grain="grain", key="salt"
                    ),
                    ret,
                )

                comt = "Query would execute, storing result in file: salt"
                ret.update({"comment": comt})
                self.assertDictEqual(
                    mysql_query.run(
                        name, database, query, output="salt", grain="grain"
                    ),
                    ret,
                )

                comt = "Query would execute, not storing result"
                ret.update({"comment": comt})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

            comt = "No execution needed. Grain grain:salt already set"
            ret.update({"comment": comt, "result": True})
            self.assertDictEqual(
                mysql_query.run(
                    name,
                    database,
                    query,
                    output="grain",
                    grain="grain",
                    key="salt",
                    overwrite=False,
                ),
                ret,
            )

            comt = "Error: output type 'grain' needs the grain parameter\n"
            ret.update({"comment": comt, "result": False})
            self.assertDictEqual(
                mysql_query.run(name, database, query, output="grain"), ret
            )

            with patch.object(os.path, "isfile", mock_t):
                comt = "No execution needed. File salt already set"
                ret.update({"comment": comt, "result": True})
                self.assertDictEqual(
                    mysql_query.run(
                        name,
                        database,
                        query,
                        output="salt",
                        grain="grain",
                        overwrite=False,
                    ),
                    ret,
                )

            with patch.dict(mysql_query.__opts__, {"test": False}):
                ret.update({"comment": "salt", "changes": {"query": "Executed"}})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)<commit_msg>Adding a test to ensure that the constant value to present when client_flags includes multi_statements.<commit_after>"""
    :codeauthor: <NAME> <<EMAIL>>
"""

import logging
import os

import salt.modules.mysql as mysql_mod
import salt.states.mysql_query as mysql_query
from tests.support.mixins import LoaderModuleMockMixin
from tests.support.mock import MagicMock, patch
from tests.support.unit import TestCase

log = logging.getLogger(__name__)


class MockMySQLConnect:
    def __init__(self, *args, **kwargs):
        self.args = args
        self.kwargs = kwargs

    def autocommit(self, *args, **kwards):
        return True

    def cursor(self, *args, **kwards):
        return MagicMock()


class MysqlQueryTestCase(TestCase, LoaderModuleMockMixin):
    """
    Test cases for salt.states.mysql_query
    """

    def setup_loader_modules(self):
        return {mysql_query: {}, mysql_mod: {}}

    # 'run' function tests: 1

    def test_run(self):
        """
        Test to execute an arbitrary query on the specified database.
        """
        name = "query_id"
        database = "my_database"
        query = "SELECT * FROM table;"

        ret = {"name": name, "result": True, "comment": "", "changes": {}}

        mock_t = MagicMock(return_value=True)
        mock_f = MagicMock(return_value=False)
        mock_str = MagicMock(return_value="salt")
        mock_none = MagicMock(return_value=None)
        mock_dict = MagicMock(return_value={"salt": "SALT"})
        mock_lst = MagicMock(return_value=["grain"])
        with patch.dict(mysql_query.__salt__, {"mysql.db_exists": mock_f}):
            with patch.object(mysql_query, "_get_mysql_error", mock_str):
                ret.update({"comment": "salt", "result": False})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

            with patch.object(mysql_query, "_get_mysql_error", mock_none):
                comt = "Database {} is not present".format(name)
                ret.update({"comment": comt, "result": None})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

        with patch.dict(
            mysql_query.__salt__,
            {
                "mysql.db_exists": mock_t,
                "grains.ls": mock_lst,
                "grains.get": mock_dict,
                "mysql.query": mock_str,
            },
        ):
            comt = "No execution needed. Grain grain already set"
            ret.update({"comment": comt, "result": True})
            self.assertDictEqual(
                mysql_query.run(
                    name,
                    database,
                    query,
                    output="grain",
                    grain="grain",
                    overwrite=False,
                ),
                ret,
            )

            with patch.dict(mysql_query.__opts__, {"test": True}):
                comt = "Query would execute, storing result in grain: grain"
                ret.update({"comment": comt, "result": None})
                self.assertDictEqual(
                    mysql_query.run(
                        name, database, query, output="grain", grain="grain"
                    ),
                    ret,
                )

                comt = "Query would execute, storing result" " in grain: grain:salt"
                ret.update({"comment": comt})
                self.assertDictEqual(
                    mysql_query.run(
                        name, database, query, output="grain", grain="grain", key="salt"
                    ),
                    ret,
                )

                comt = "Query would execute, storing result in file: salt"
                ret.update({"comment": comt})
                self.assertDictEqual(
                    mysql_query.run(
                        name, database, query, output="salt", grain="grain"
                    ),
                    ret,
                )

                comt = "Query would execute, not storing result"
                ret.update({"comment": comt})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

            comt = "No execution needed. Grain grain:salt already set"
            ret.update({"comment": comt, "result": True})
            self.assertDictEqual(
                mysql_query.run(
                    name,
                    database,
                    query,
                    output="grain",
                    grain="grain",
                    key="salt",
                    overwrite=False,
                ),
                ret,
            )

            comt = "Error: output type 'grain' needs the grain parameter\n"
            ret.update({"comment": comt, "result": False})
            self.assertDictEqual(
                mysql_query.run(name, database, query, output="grain"), ret
            )

            with patch.object(os.path, "isfile", mock_t):
                comt = "No execution needed. File salt already set"
                ret.update({"comment": comt, "result": True})
                self.assertDictEqual(
                    mysql_query.run(
                        name,
                        database,
                        query,
                        output="salt",
                        grain="grain",
                        overwrite=False,
                    ),
                    ret,
                )

            with patch.dict(mysql_query.__opts__, {"test": False}):
                ret.update({"comment": "salt", "changes": {"query": "Executed"}})
                self.assertDictEqual(mysql_query.run(name, database, query), ret)

    def test_run_multiple_statements(self):
        """
        Test to execute an arbitrary query on the specified database
        and ensure that the correct multi_statements flag is passed along
        to MySQLdb.connect.
        """
        name = "query_id"
        database = "my_database"
        query = "SELECT * FROM table; SELECT * from another_table;"

        mock_t = MagicMock(return_value=True)

        with patch.dict(mysql_query.__salt__, {"mysql.db_exists": mock_t}), patch.dict(
            mysql_query.__opts__, {"test": False}
        ), patch.dict(
            mysql_query.__salt__, {"mysql.query": mysql_mod.query}
        ), patch.dict(
            mysql_query.__salt__, {"mysql._execute": MagicMock()}
        ), patch.dict(
            mysql_mod.__salt__, {"config.option": MagicMock()}
        ), patch(
            "MySQLdb.connect", return_value=MockMySQLConnect()
        ) as mock_connect:
            ret = mysql_query.run(
                name, database, query, client_flags=["multi_statements"]
            )
            self.assertEqual(1, len(mock_connect.mock_calls))
            self.assertIn("client_flag=65536", str(mock_connect.mock_calls[0]))
{'fraction_non_alphanumeric': 0.10935452162516383, 'fraction_numerical': 0.0009010484927916121, 'mean_word_length': 1.55418410041841, 'pattern_counts': {'":': 69, '<': 9, '<?xml version=': 0, '>': 9, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '959566', 'n_tokens_mistral': 3308, 'n_tokens_neox': 3080, 'n_words': 733}