def test_unhold(self): """ Test for put message(s) on hold from the mail queue """ with patch.object(postfix, "show_queue", return_value={}): self.assertDictEqual( postfix.unhold("queue_id"), { "result": False, "message": "No message in queue with ID queue_id" }, ) with patch.dict( postfix.__salt__, {"cmd.run_all": MagicMock(return_value={"retcode": 0})}): self.assertDictEqual( postfix.unhold("ALL"), { "result": True, "message": "Successfully set all message as unheld" }, )
def test_install_with_options(self): parse_targets = MagicMock(return_value=({'foo': None}, 'repository')) with patch.object(yumpkg, 'list_pkgs', MagicMock(return_value={})), \ patch.object(yumpkg, 'list_holds', MagicMock(return_value=[])), \ patch.dict(yumpkg.__salt__, {'pkg_resource.parse_targets': parse_targets}), \ patch('salt.utils.systemd.has_scope', MagicMock(return_value=False)): # with fromrepo cmd = MagicMock(return_value={'retcode': 0}) with patch.dict(yumpkg.__salt__, {'cmd.run_all': cmd}): yumpkg.install(refresh=False, fromrepo='good', branch='foo', setopt='obsoletes=0,plugins=0') cmd.assert_called_once_with([ 'yum', '-y', '--disablerepo=*', '--enablerepo=good', '--branch=foo', '--setopt', 'obsoletes=0', '--setopt', 'plugins=0', 'install', 'foo' ], env={}, output_loglevel='trace', python_shell=False, ignore_retcode=False, redirect_stderr=True) # without fromrepo cmd = MagicMock(return_value={'retcode': 0}) with patch.dict(yumpkg.__salt__, {'cmd.run_all': cmd}): yumpkg.install(refresh=False, enablerepo='good', disablerepo='bad', branch='foo', setopt='obsoletes=0,plugins=0') cmd.assert_called_once_with( [ 'yum', '-y', '--disablerepo=bad', '--enablerepo=good', '--branch=foo', '--setopt', 'obsoletes=0', '--setopt', 'plugins=0', 'install', 'foo' ], env={}, output_loglevel='trace', python_shell=False, ignore_retcode=False, redirect_stderr=True, )
def test_hook_can_handle_get_parameters(self): with patch('salt.utils.event.get_event') as get_event: with patch.dict(self._app.mod_opts, {'webhook_disable_auth': True}): event = MagicMock() event.fire_event.return_value = True get_event.return_value = event response = self.fetch('/hook/my_service/?param=1¶m=2', body=salt.utils.json.dumps({}), method='POST', headers={'Content-Type': self.content_type_map['json']}) self.assertEqual(response.code, 200, response.body) host = urlparse(response.effective_url).netloc event.fire_event.assert_called_once_with( {'headers': {'Content-Length': '2', 'Connection': 'close', 'Content-Type': 'application/json', 'Host': host, 'Accept-Encoding': 'gzip'}, 'post': {}, 'get': {'param': ['1', '2']} }, 'salt/netapi/hook/my_service/', )
def test_examine(self): """ Test for mdadm_raid.examine """ mock = MagicMock( return_value=( "ARRAY /dev/md/pool metadata=1.2" " UUID=567da122:fb8e445e:55b853e0:81bd0a3e name=positron:pool" ) ) with patch.dict(mdadm.__salt__, {"cmd.run_stdout": mock}): self.assertEqual( mdadm.examine("/dev/md0"), { "ARRAY /dev/md/pool metadata": ( "1.2 UUID=567da122:fb8e445e:55b853e0:81bd0a3e" " name=positron:pool" ) }, ) mock.assert_called_with( "mdadm -Y -E /dev/md0", ignore_retcode=False, python_shell=False )
def test_source_address(self): ''' test when source_address is set ''' interfaces = {'bond0.1234': {'hwaddr': '01:01:01:d0:d0:d0', 'up': False, 'inet': [{'broadcast': '111.1.111.255', 'netmask': '111.1.0.0', 'label': 'bond0', 'address': '111.1.0.1'}]}} with patch.dict(__opts__, {'ipv6': False, 'master': '127.0.0.1', 'master_port': '4555', 'file_client': 'local', 'source_interface_name': '', 'source_address': '111.1.0.1', 'source_ret_port': 49017, 'source_publish_port': 49018}), \ patch('salt.utils.network.interfaces', MagicMock(return_value=interfaces)): assert salt.minion.resolve_dns(__opts__) == {'source_publish_port': 49018, 'source_ret_port': 49017, 'master_uri': 'tcp://127.0.0.1:4555', 'source_ip': '111.1.0.1', 'master_ip': '127.0.0.1'}
def test_present_nocreation(self): with patch.dict( postgres_schema.__salt__, { 'postgres.schema_get': Mock(return_value={'foo': { 'acl': '', 'owner': 'postgres' }}), 'postgres.schema_create': MagicMock() }): ret = postgres_schema.present('dbname', 'foo') self.assertEqual( ret, { 'comment': 'Schema foo already exists in database dbname', 'changes': {}, 'dbname': 'dbname', 'name': 'foo', 'result': True }) self.assertEqual( self.salt_stub['postgres.schema_create'].call_count, 0)
def test_get_success(self): ''' Tests zfs get success ''' res = OrderedDict([ ('myzpool', OrderedDict([ ('used', OrderedDict([ ('value', 906238099456), ])), ])), ]) ret = { 'pid': 562, 'retcode': 0, 'stderr': '', 'stdout': 'myzpool\tused\t906238099456' } mock_cmd = MagicMock(return_value=ret) with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}), \ patch.dict(zfs.__utils__, utils_patch): self.assertEqual( res, zfs.get('myzpool', properties='used', fields='value'))
def test_eval_cron(self): ''' verify that scheduled job runs ''' job = { 'schedule': { 'job1': { 'function': 'test.ping', 'cron': '0 16 29 11 *' } } } # Add the job to the scheduler self.schedule.opts.update(job) run_time = dateutil_parser.parse('11/29/2017 4:00pm') with patch('croniter.croniter.get_next', MagicMock(return_value=run_time)): self.schedule.eval(now=run_time) ret = self.schedule.job_status('job1') self.assertEqual(ret['_last_run'], run_time)
def test_list_snapshots(self): ''' Test parallels.list_snapshots ''' name = 'macvm' guid_str = textwrap.dedent(''' PARENT_SNAPSHOT_ID SNAPSHOT_ID {a5b8999f-5d95-4aff-82de-e515b0101b66} {a5b8999f-5d95-4aff-82de-e515b0101b66} *{a7345be5-ab66-478c-946e-a6c2caf14909} {a5b8999f-5d95-4aff-82de-e515b0101b66} {5da9faef-cb0e-466d-9b41-e5571b62ac2a} ''') # Validate listing all snapshots for the VM mock_prlctl = MagicMock(return_value=guid_str) with patch.object(parallels, 'prlctl', mock_prlctl): parallels.list_snapshots(name) mock_prlctl.assert_called_once_with('snapshot-list', [name], runas=None) # Validate listing all snapshots in tree mode mock_prlctl = MagicMock(return_value=guid_str) with patch.object(parallels, 'prlctl', mock_prlctl): parallels.list_snapshots(name, tree=True) mock_prlctl.assert_called_once_with('snapshot-list', [name, '--tree'], runas=None) # Validate listing a single snapshot snap_name = 'muon' mock_snap_name = MagicMock(return_value=snap_name) with patch.object(parallels, '_validate_snap_name', mock_snap_name): mock_prlctl = MagicMock(return_value=guid_str) with patch.object(parallels, 'prlctl', mock_prlctl): parallels.list_snapshots(name, snap_name) mock_prlctl.assert_called_once_with('snapshot-list', [name, '--id', snap_name], runas=None) # Validate listing snapshot ID and name pairs snap_names = ['electron', 'muon', 'tauon'] mock_snap_name = MagicMock(side_effect=snap_names) with patch.object(parallels, 'snapshot_id_to_name', mock_snap_name): mock_prlctl = MagicMock(return_value=guid_str) with patch.object(parallels, 'prlctl', mock_prlctl): ret = parallels.list_snapshots(name, names=True) for snap_name in snap_names: self.assertIn(snap_name, ret) mock_prlctl.assert_called_once_with('snapshot-list', [name], runas=None)
def test_macro_additional_log_syntaxerror(self): ''' If we failed in a macro, get more output from trace. ''' expected = r'''Jinja syntax error: expected token .*end.*got '-'.* .*/macroerror\(2\): --- # macro \{% macro mymacro\(greeting, greetee='world'\) -\} <-- error is here <====================== \{\{ greeting ~ ' ' ~ greetee \}\} ! \{%- endmacro %\} ---.*''' filename = os.path.join(TEMPLATES_DIR, 'files', 'test', 'hello_import_error') fc = MockFileClient() with patch.object(SaltCacheLoader, 'file_client', MagicMock(return_value=fc)): with salt.utils.fopen(filename) as fp_: self.assertRaisesRegex( SaltRenderError, expected, render_jinja_tmpl, fp_.read(), dict(opts=self.local_opts, saltenv='test', salt=self.local_salt))
def test_rename_set(self): ''' Test for Delete ipset set. ''' self.assertEqual(ipset.rename_set(), 'Error: Set needs to be specified') self.assertEqual(ipset.rename_set('s'), 'Error: New name for set needs to be specified') with patch.object(ipset, '_find_set_type', return_value=False): self.assertEqual(ipset.rename_set('s', 'd'), 'Error: Set does not exist') with patch.object(ipset, '_find_set_type', return_value=True): self.assertEqual(ipset.rename_set('s', 'd'), 'Error: New Set already exists') with patch.object(ipset, '_find_set_type', side_effect=[True, False]): with patch.object(ipset, '_ipset_cmd', return_value='A'): mock = MagicMock(return_value=True) with patch.dict(ipset.__salt__, {'cmd.run': mock}): self.assertTrue(ipset.rename_set('set', 'new_set'))
def test_macro_additional_log_for_undefined(self): ''' If we failed in a macro because of undefined variables, get more output from trace. ''' expected = r'''Jinja variable 'b' is undefined .*/macroundefined\(2\): --- \{% macro mymacro\(\) -%\} \{\{b.greetee\}\} <-- error is here <====================== \{%- endmacro %\} ---''' filename = os.path.join(TEMPLATES_DIR, 'files', 'test', 'hello_import_undefined') fc = MockFileClient() with patch.object(SaltCacheLoader, 'file_client', MagicMock(return_value=fc)): with salt.utils.fopen(filename) as fp_: self.assertRaisesRegex( SaltRenderError, expected, render_jinja_tmpl, fp_.read(), dict(opts=self.local_opts, saltenv='test', salt=self.local_salt))
def test_macro_additional_log_for_generalexc(self): ''' If we failed in a macro because of e.g. a TypeError, get more output from trace. ''' expected = r'''Jinja error:.*division.* .*/macrogeneral\(2\): --- \{% macro mymacro\(\) -%\} \{\{ 1/0 \}\} <====================== \{%- endmacro %\} ---.*''' filename = os.path.join(TEMPLATES_DIR, 'files', 'test', 'hello_import_generalerror') fc = MockFileClient() with patch.object(SaltCacheLoader, 'file_client', MagicMock(return_value=fc)): with salt.utils.fopen(filename) as fp_: self.assertRaisesRegex( SaltRenderError, expected, render_jinja_tmpl, fp_.read(), dict(opts=self.local_opts, saltenv='test', salt=self.local_salt))
def test_delete(self): """ Test for delete message(s) from the mail queue """ with patch.object(postfix, "show_queue", return_value={}): self.assertDictEqual( postfix.delete("queue_id"), { "result": False, "message": "No message in queue with ID queue_id" }, ) with patch.dict( postfix.__salt__, {"cmd.run_all": MagicMock(return_value={"retcode": 0})}): self.assertDictEqual( postfix.delete("ALL"), { "result": True, "message": "Successfully removed all messages" }, )
def test_get_policies_for_nonexisting_minions(self): minion_id = "salt_master" # For non-existing minions, or the master-minion, grains will be None cases = { "no-tokens-to-replace": ["no-tokens-to-replace"], "single-dict:{minion}": ["single-dict:{0}".format(minion_id)], "single-list:{grains[roles]}": [], } with patch( "salt.utils.minions.get_minion_data", MagicMock(return_value=(None, None, None)), ): for case, correct_output in six.iteritems(cases): test_config = {"policies": [case]} output = vault._get_policies( minion_id, test_config ) # pylint: disable=protected-access diff = set(output).symmetric_difference(set(correct_output)) if diff: log.debug("Test %s failed", case) log.debug("Expected:\n\t%s\nGot\n\t%s", output, correct_output) log.debug("Difference:\n\t%s", diff) self.assertEqual(output, correct_output)
def test_send_msg(self): ''' Test to send a message to an XMPP user ''' ret = {'name': 'salt', 'changes': {}, 'result': None, 'comment': ''} with patch.dict(xmpp.__opts__, {"test": True}): ret.update({'comment': 'Need to send message to myaccount: salt'}) self.assertDictEqual( xmpp.send_msg('salt', 'myaccount', '*****@*****.**'), ret) with patch.dict(xmpp.__opts__, {"test": False}): mock = MagicMock(return_value=True) with patch.dict(xmpp.__salt__, { 'xmpp.send_msg': mock, 'xmpp.send_msg_multi': mock }): ret.update({ 'result': True, 'comment': 'Sent message to myaccount: salt' }) self.assertDictEqual( xmpp.send_msg('salt', 'myaccount', '*****@*****.**'), ret)
def test_created_startup(self): ''' Test with one vm and startup_create_event ''' # NOTE: this should yield 1 created event + one state event with patch.dict(vmadm.VMADM_STATE, MOCK_CLEAN_STATE), \ patch.dict(vmadm.__salt__, {'vmadm.list': MagicMock(return_value=MOCK_VM_ONE)}): config = [{'startup_create_event': True}] ret = vmadm.validate(config) self.assertEqual(ret, (True, 'Valid beacon configuration')) ret = vmadm.beacon(config) res = [{'alias': 'vm1', 'tag': 'created/00000000-0000-0000-0000-000000000001', 'hostname': 'vm1', 'dns_domain': 'example.org'}, {'alias': 'vm1', 'tag': 'running/00000000-0000-0000-0000-000000000001', 'hostname': 'vm1', 'dns_domain': 'example.org'}] self.assertEqual(ret, res)
def test_nothing_to_be_done_test_mode(self): with patch.dict(esxdatacenter.__opts__, {"test": True}): with patch.dict( esxdatacenter.__salt__, { "vsphere.get_proxy_type": MagicMock(return_value="different_proxy") }, ): res = esxdatacenter.datacenter_configured("fake_dc") self.assertDictEqual( res, { "name": "fake_dc", "changes": {}, "result": True, "comment": "Datacenter 'fake_dc' already " "exists. Nothing to be done.", }, )
def test_diff(self): ''' Tests zfs diff ''' res = [ "1517063879.144517494\tM\t\t/data/test/", "1517063875.296592355\t+\t\t/data/test/world", "1517063879.274438467\t+\t\t/data/test/hello", ] ret = {} ret['retcode'] = 0 ret['stdout'] = "\n".join([ "1517063879.144517494\tM\t\t/data/test/", "1517063875.296592355\t+\t\t/data/test/world", "1517063879.274438467\t+\t\t/data/test/hello", ]) ret['stderr'] = '' mock_cmd = MagicMock(return_value=ret) with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}), \ patch.dict(zfs.__utils__, utils_patch): self.assertEqual( res, zfs.diff('myzpool/mydataset@yesterday', 'myzpool/mydataset'))
def test_log_created(self): """ Tests that log file is created """ args = self.args log_file = self.log_file log_file_name = self.logfile_config_setting_name opts = self.testing_config.copy() opts.update({"log_file": log_file}) if log_file_name != "log_file": opts.update({log_file_name: getattr(self, log_file_name)}) if log_file_name == "key_logfile": self.skipTest("salt-key creates log file outside of parse_args.") parser = self.parser() with patch(self.config_func, MagicMock(return_value=opts)): parser.parse_args(args) if log_file_name == "log_file": self.assertEqual(os.path.getsize(log_file), 0) else: self.assertEqual(os.path.getsize(getattr(self, log_file_name)), 0)
def test_recv_known_hosts_hashed_shoud_be_findable_by_ssh_keygen(self): hostname = 'example.com' port = 12345 with tempfile.NamedTemporaryFile(mode='w+', delete=False) as temp_file: with patch.dict(ssh.__salt__, {'cmd.run': MagicMock(side_effect=_mock_ssh_keyscan)}): entries = ssh.recv_known_host_entries( hostname=hostname, port=port, hash_known_hosts=True, ) for entry in entries: print( '{0[hostname]} {0[enc]} {0[key]}'.format(entry), file=temp_file, ) temp_file.flush() result = subprocess.check_output([ 'ssh-keygen', '-f', temp_file.name, '-F', '[{hostname}]:{port}'.format(hostname=hostname, port=port), ])
def test_match_index_versions(self): """ Test to verifies that the master and the slave versions are in sync by comparing the index version. """ err = 'solr.match_index_versions can only be called by "slave" minions' with patch.object(solr, "_get_return_dict", return_value={"A": "a"}): with patch.object(solr, "_is_master", side_effect=[True, False]): self.assertIsNone(solr.match_index_versions()) with patch.object(solr, "_get_none_or_value", return_value=None): with patch.object(solr, "_check_for_cores", return_value=True): with patch.dict( solr.__opts__, {"solr.cores": MagicMock(return_value="A")} ): with patch.object( solr, "_replication_request", return_value="A" ): self.assertDictEqual( solr.match_index_versions(), {"A": "a", "errors": [err], "success": False}, )
def test_log_created(self): ''' Tests that log file is created ''' args = self.args log_file = self.log_file log_file_name = self.logfile_config_setting_name opts = self.default_config.copy() opts.update({'log_file': log_file}) if log_file_name != 'log_file': opts.update({log_file_name: getattr(self, log_file_name)}) if log_file_name == 'key_logfile': self.skipTest('salt-key creates log file outside of parse_args.') parser = self.parser() with patch(self.config_func, MagicMock(return_value=opts)): parser.parse_args(args) if log_file_name == 'log_file': self.assertEqual(os.path.getsize(log_file), 0) else: self.assertEqual(os.path.getsize(getattr(self, log_file_name)), 0)
def test_set_replication_enabled(self): """ Test to sets the master to ignore poll requests from the slaves. """ with patch.object(solr, "_is_master", side_effect=[False, True, True, True]): with patch.object( solr, "_get_none_or_value", side_effect=[None, None, True, True, True] ): with patch.object( solr, "_get_return_dict", side_effect=[{"A": "a"}, {}] ): with patch.object(solr, "_replication_request", return_value="A"): self.assertDictEqual( solr.set_replication_enabled("s"), {"A": "a"} ) with patch.object(solr, "_check_for_cores", return_value=True): with patch.dict( solr.__opts__, {"solr.cores": MagicMock(return_value="n")}, ): self.assertEqual(solr.set_replication_enabled("s"), {}) self.assertEqual(solr.set_replication_enabled("s"), "A") self.assertEqual(solr.set_replication_enabled(False), "A")
def test_service_present(self): ''' Test to ensure service present in Keystone catalog ''' name = 'nova' service_type = 'compute' ret = {'name': name, 'changes': {}, 'result': True, 'comment': 'Service "{0}" already exists'.format(name)} mock_lst = MagicMock(side_effect=[[], ['Error']]) with patch.dict(keystone.__salt__, {'keystone.service_get': mock_lst}): self.assertDictEqual(keystone.service_present(name, service_type), ret) with patch.dict(keystone.__opts__, {'test': True}): comt = ('Service "{0}" will be added'.format(name)) ret.update({'comment': comt, 'result': None}) self.assertDictEqual(keystone.service_present(name, service_type), ret)
def test_reload_core(self): """ Test to load a new core from the same configuration as an existing registered core. """ error = ['solr.reload_core can only be called by "multi-core" minions'] with patch.object( solr, "_check_for_cores", side_effect=[False, True, True, True] ): with patch.object(solr, "_get_none_or_value", side_effect=[None, True]): with patch.object(solr, "_get_return_dict", return_value={"A": "a"}): with patch.object(solr, "_format_url", return_value="A"): with patch.object(solr, "_http_request", return_value="A"): with patch.dict( solr.__opts__, {"solr.cores": MagicMock(return_value="n")}, ): self.assertIsNone(solr.reload_core()) self.assertDictEqual( solr.reload_core(), {"A": "a", "errors": error, "success": False}, ) self.assertEqual(solr.reload_core(), "A")
def setUp(self): self.name = "zabbix" self.context = "/files/etc/services" self.changes = [ "ins service-name after service-name[last()]", "set service-name[last()] zabbix-agent", ] self.fp_changes = [ "ins service-name after /files/etc/services/service-name[last()]", "set /files/etc/services/service-name[last()] zabbix-agent", ] self.ret = {"name": self.name, "result": False, "changes": {}, "comment": ""} method_map = { "set": "set", "setm": "setm", "mv": "move", "move": "move", "ins": "insert", "insert": "insert", "rm": "remove", "remove": "remove", } self.mock_method_map = MagicMock(return_value=method_map)
def test_absent_test_mode(self): """ Test to ensure that named action is absent in test mode """ name = "Auto registration Databases" ret = {"name": name, "result": False, "comment": "", "changes": {}} with patch.dict(zabbix_action.__opts__, {"test": True}): with patch.dict( zabbix_action.__salt__, {"zabbix.get_object_id_by_params": MagicMock(return_value=11)}, ): ret["result"] = True ret["comment"] = 'Zabbix Action "{0}" would be deleted.'.format( name) ret["changes"] = { name: { "old": 'Zabbix Action "{0}" exists.'.format(name), "new": 'Zabbix Action "{0}" would be deleted.'.format(name), } } self.assertDictEqual(zabbix_action.absent(name), ret)
def test_rebooted(self): ''' rebooted state test cases. ''' ret = {'name': 'myvm', 'changes': {}, 'result': True} reboot_mock = MagicMock(return_value=True) with patch.dict(virt.__salt__, { # pylint: disable=no-member 'virt.list_domains': MagicMock(return_value=['myvm', 'vm1']), 'virt.reboot': reboot_mock }): ret.update({'changes': { 'rebooted': [{'domain': 'myvm', 'reboot': True}] }, 'comment': 'Machine has been rebooted'}) self.assertDictEqual(virt.rebooted('myvm'), ret) reboot_mock.assert_called_with('myvm', connection=None, username=None, password=None) with patch.dict(virt.__salt__, { # pylint: disable=no-member 'virt.list_domains': MagicMock(return_value=['myvm', 'vm1']), 'virt.reboot': reboot_mock, }): self.assertDictEqual(virt.rebooted('myvm', connection='myconnection', username='******', password='******'), ret) reboot_mock.assert_called_with('myvm', connection='myconnection', username='******', password='******') with patch.dict(virt.__salt__, { # pylint: disable=no-member 'virt.list_domains': MagicMock(return_value=['myvm', 'vm1']), 'virt.reboot': MagicMock(side_effect=self.mock_libvirt.libvirtError('Some error')) }): ret.update({'changes': {'ignored': [{'domain': 'myvm', 'issue': 'Some error'}]}, 'result': False, 'comment': 'No changes had happened'}) self.assertDictEqual(virt.rebooted('myvm'), ret) with patch.dict(virt.__salt__, {'virt.list_domains': MagicMock(return_value=[])}): # pylint: disable=no-member ret.update({'changes': {}, 'result': False, 'comment': 'No changes had happened'}) self.assertDictEqual(virt.rebooted('myvm'), ret)
def test_user_chpass(self): """ Test changing a MySQL user password in mysql exec module """ connect_mock = MagicMock() with patch.object(mysql, "_connect", connect_mock): with patch.object(mysql, "version", return_value="8.0.10"): with patch.object(mysql, "user_exists", MagicMock(return_value=True)): with patch.dict(mysql.__salt__, {"config.option": MagicMock()}): mysql.user_chpass("testuser", password="******") calls = ( call().cursor().execute( "UPDATE mysql.user SET Password=PASSWORD(%(password)s) WHERE User=%(user)s AND Host = %(host)s;", { "password": "******", "user": "******", "host": "localhost", }, ), call().cursor().execute("FLUSH PRIVILEGES;"), ) connect_mock.assert_has_calls(calls, any_order=True) connect_mock = MagicMock() with patch.object(mysql, "_connect", connect_mock): with patch.object(mysql, "version", return_value="8.0.11"): with patch.object(mysql, "user_exists", MagicMock(return_value=True)): with patch.dict(mysql.__salt__, {"config.option": MagicMock()}): mysql.user_chpass("testuser", password="******") calls = ( call().cursor().execute( "ALTER USER %(user)s@%(host)s IDENTIFIED BY %(password)s;", { "password": "******", "user": "******", "host": "localhost", }, ), call().cursor().execute("FLUSH PRIVILEGES;"), ) connect_mock.assert_has_calls(calls, any_order=True)