Python MagicMock.configure_mock方法代码示例

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
async def test_pop_alerts(monkeypatch):
    session = MagicMock()

    alert_test_one = AlertTestOne()
    alert_test_two = AlertTestTwo()

    session.configure_mock(**{
        'wait_for_alert.return_value': True,
        'pop_alerts.return_value': [alert_test_one, alert_test_two],
    })

    monkeypatch.setattr('libtorrent.alert.category_t', CategoryT)
    a = spritzle.alert.Alert()
    a.session = session

    handler_one = asynctest.CoroutineMock()
    a.register_handler('AlertTestOne', handler_one)
    assert 'AlertTestOne' in a.handlers

    handler_two = asynctest.CoroutineMock()
    a.register_handler('AlertTestTwo', handler_two)
    assert 'AlertTestTwo' in a.handlers

    handler_three = asynctest.CoroutineMock()
    a.register_handler('test_category1', handler_three)
    assert 'test_category1' in a.handlers

    await a.pop_alerts(run_once=True)

    handler_one.assert_called_with(alert_test_one)
    handler_two.assert_called_with(alert_test_two)
    handler_three.assert_called_with(alert_test_one)

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
 def test_changing_magic_set_in_initialization(self):
     m = MagicMock(**{'__str__.return_value': "12"})
     m.__str__.return_value = "13"
     self.assertEqual(str(m), "13")
     m = MagicMock(**{'__str__.return_value': "12"})
     m.configure_mock(**{'__str__.return_value': "14"})
     self.assertEqual(str(m), "14")

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def _get_free_device(self, size=Size("8 GiB"), logical=False, parent=None, **kwargs):
        if not parent:
            parent = MagicMock()
            parent.configure_mock(name="vda", size=size, type="disk")

        free_region = kwargs.get("is_free_region", True)
        empty_disk = kwargs.get("is_empty_disk", False)
        uninitialized_disk = kwargs.get("is_uninitialized_disk", False)

        return MagicMock(type="free_space", size=size, is_logical=logical, parents=[parent],
                         is_free_region=free_region, is_empty_disk=empty_disk, is_uninitialized_disk=uninitialized_disk)

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def supported_raids(self):
        single = MagicMock()
        single.configure_mock(name="single", min_members=1)
        linear = MagicMock()
        linear.configure_mock(name="linear", min_members=1)
        raid0 = MagicMock()
        raid0.configure_mock(name="raid0", min_members=2)
        raid1 = MagicMock()
        raid1.configure_mock(name="raid1", min_members=2)
        raid5 = MagicMock()
        raid5.configure_mock(name="raid5", min_members=3)

        return {"btrfs volume": (single, raid0, raid1), "mdraid": (linear, raid0, raid1)}

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
def make_language(name, source_extensions, header_extensions,
                  compilation_command, evaluation_command):
    """Create a language (actually a MagicMock) with the given data."""
    language = MagicMock()
    language.configure_mock(name=name,
                            source_extensions=source_extensions,
                            source_extension=source_extensions[0],
                            header_extensions=header_extensions,
                            header_extension=header_extensions[0])
    language.get_compilation_commands.side_effect = \
        functools.partial(fake_compilation_commands, compilation_command)
    language.get_evaluation_commands.side_effect = \
        functools.partial(fake_evaluation_commands, evaluation_command)
    return language

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def setUp(self):
        self.tmp_dir = tempfile.TemporaryDirectory()
        self.real_config = mbm.config
        mbm.config = MagicMock()
        self.controller = mbm.controller.Controller(
            global_conf_path=self.tmp_dir.name,
            accounts_path=self.tmp_dir.name + "/accounts")
        self.accounts = [MagicMock(), MagicMock()]

        attrs = {'get_model.side_effect': mbm.datatype.ProviderException}
        account_provider_exception = MagicMock()
        account_provider_exception.configure_mock(**attrs)
        self.accounts_provider_exception = [account_provider_exception,
                                            account_provider_exception]

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def test(unittes):#, dumperMock):

        text = "text"
        attrs = {'dump.return_value': text}
        dumperMock = MagicMock(**attrs)
        
        dumperMockNew = MagicMock()
        attrs = {'dump.return_value': 'new text'}
        dumperMockNew.configure_mock(**attrs)

        # attrs = {'create.return_value': dumperMock, 'createNew.return_value': dumperMockNew}
        mock = MagicMock(return_value=MagicMock(),**{'create.return_value': dumperMock, 'createNew.return_value': dumperMockNew} )
        # mock.configure_mock(**attrs)
        dump = mock.create()
        print(dump.dump())


        dump = mock.create()
        print(dump.dump())

        dump = mock.createNew()
        print(dump.dump())

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def _get_parent_device(self, name=None, dtype="disk", size=Size("8 GiB"), ftype="disklabel"):
        if not name:
            if dtype == "disk":
                name = "vda"
            else:
                name = "fedora"

        dev = MagicMock()
        dev.configure_mock(name=name, type=dtype, size=size, format=MagicMock(type=ftype))
        if dtype == "lvmvg":
            pv = MagicMock()
            pv.configure_mock(name="vda1", size=size, format=MagicMock(free=size), disk=self._get_parent_device())
            dev.configure_mock(pe_size=Size("4 MiB"), free_space=size, pvs=[pv], pmspare_size=Size("4 MiB"))

        return dev

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def test_add_to_store(self):

        # simple partition -- test if added to store correctly
        device = MagicMock(type="partition", size=Size("1 GiB"),
                           format=MagicMock(type="ext4", mountable=True, mountpoint=None, system_mountpoint="/"))
        device.configure_mock(name="vda1")

        it = self.list_partitions._add_to_store(device)
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 1), device.name)
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 2), device.type)
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 3), device.format.type)
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 4), str(device.size))
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 5), device.format.system_mountpoint)

        # lvmvg with long name -- name should be elipsized and type should be 'lvm'
        device = MagicMock(type="lvmvg", size=Size("1 GiB"),
                           format=MagicMock(type=None, mountable=False, mountpoint=None, system_mountpoint=None))
        device.configure_mock(name="".join(["a" for i in range(20)]))

        it = self.list_partitions._add_to_store(device)
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 1), device.name[:15] + "...")
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 2), "lvm")
        self.assertIsNone(self.list_partitions.partitions_list.get_value(it, 3))
        self.assertEqual(self.list_partitions.partitions_list.get_value(it, 4), str(device.size))
        self.assertIsNone(self.list_partitions.partitions_list.get_value(it, 5))

        # child device of previously added device
        device = MagicMock(type="lvmlv", size=Size("1 GiB"),
                           format=MagicMock(type="ext4", mountable=True, mountpoint=None, system_mountpoint="/home"))
        device.configure_mock(name="aaa")

        child_it = self.list_partitions._add_to_store(device, it)
        # check that 'child_it' is actually child of 'it'
        self.assertEqual(self.list_partitions.partitions_list[self.list_partitions.partitions_list.iter_children(it)][0],
                         self.list_partitions.partitions_list[child_it][0])
        self.assertEqual(self.list_partitions.partitions_list.get_value(child_it, 1), device.name)
        self.assertEqual(self.list_partitions.partitions_list.get_value(child_it, 2), "lvmlv")
        self.assertEqual(self.list_partitions.partitions_list.get_value(child_it, 3), device.format.type)
        self.assertEqual(self.list_partitions.partitions_list.get_value(child_it, 4), str(device.size))
        self.assertEqual(self.list_partitions.partitions_list.get_value(child_it, 5), device.format.system_mountpoint)

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
    def test_resizable(self):
        device = MagicMock(type="", size=Size("1 GiB"))
        device.format = MagicMock(exists=True)
        device.format.return_value = None

        # swap is not resizable
        device.format.configure_mock(type="swap")
        res = BlivetUtils.device_resizable(MagicMock(), device)
        self.assertFalse(res.resizable)
        self.assertIsNone(res.error)
        self.assertEqual(res.min_size, Size("1 MiB"))
        self.assertEqual(res.max_size, Size("1 GiB"))

        # resizable device
        device.configure_mock(resizable=True, max_size=Size("2 GiB"), min_size=Size("500 MiB"))
        device.format.configure_mock(resizable=True, type="ext4")
        res = BlivetUtils.device_resizable(MagicMock(), device)
        self.assertTrue(res.resizable)
        self.assertIsNone(res.error)
        self.assertEqual(res.min_size, Size("500 MiB"))
        self.assertEqual(res.max_size, Size("2 GiB"))

        # resizable device and non-resizable format
        device.configure_mock(resizable=True, max_size=Size("2 GiB"), min_size=Size("500 MiB"))
        device.format.configure_mock(resizable=False, type="ext4")
        res = BlivetUtils.device_resizable(MagicMock(), device)
        self.assertFalse(res.resizable)
        self.assertIsNone(res.error)
        self.assertEqual(res.min_size, Size("1 MiB"))
        self.assertEqual(res.max_size, Size("1 GiB"))

        # LV with snapshot -> not resizable
        device.configure_mock(type="lvmlv", resizable=True, max_size=Size("2 GiB"), min_size=Size("500 MiB"))
        device.format.configure_mock(resizable=True, type="ext4")
        res = BlivetUtils.device_resizable(MagicMock(), device)
        self.assertFalse(res.resizable)
        self.assertIsNotNone(res.error)
        self.assertEqual(res.min_size, Size("1 MiB"))
        self.assertEqual(res.max_size, Size("1 GiB"))

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
 def test_drive_server_mapping(self):
     controller = ecmd.controller.Controller("user", "pass", "base_url")
     attrs_gen = {"__gt__": lambda: 0,
                  "__lt__": lambda: 0,
                  "__eq__": lambda: 0,
                  }
     attrs_server1 = {"uid": "123", "name": "server1", "block:0": "789"}
     attrs_server2 = {"uid": "456", "name": "server2", "block:0": "789"}
     attrs_drive = {"uid": "789", "name": "drive"}
     attrs_server1.update(attrs_gen)
     attrs_server2.update(attrs_gen)
     attrs_drive.update(attrs_gen)
     server1 = MagicMock()
     server2 = MagicMock()
     drive = MagicMock()
     server1.configure_mock(**attrs_server1)
     server2.configure_mock(**attrs_server2)
     drive.configure_mock(**attrs_drive)
     controller.servers = [server1, server2]
     controller.drives = [drive, drive]
     mapping = controller.drive_server_mapping()
     self.assertDictEqual(mapping, dict([('server1', ['drive', 'drive']),
                                         ('server2', ['drive', 'drive'])]))

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
def make_language(name, source_extensions):
    language = MagicMock()
    language.configure_mock(name=name,
                            source_extensions=source_extensions,
                            source_extension=source_extensions[0])
    return language

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
class twitterTestCase(unittest.TestCase):

    def setUp(self):
        self.real_api = mbm.lib.api.Api
        mbm.lib.api.Api = MagicMock()

        self.tmp_dir = tempfile.TemporaryDirectory()
        cfg_parser = configparser.ConfigParser()
        self.conf_file = os.path.join(self.tmp_dir.name, "twitter.ini")
        cfg_parser.read_dict({'DEFAULT': {'username': 'tmblr_user',
                                          'account_type': 'twitter',
                                          'token': '123token456',
                                          'token_secret': '123token_secret456',
                                          },
                              })
        with open(self.conf_file, 'w') as conf:
            cfg_parser.write(conf)

        cfg_parser.read_dict({'twitter': {'consumer_key': 'CONSUMER_KEY',
                                          'consumer_secret': 'CONSUMER_SECRET',
                                          },
                              })
        global_conf = MagicMock(**{'config': cfg_parser})

        attrs_success = {'code': 200,
                         'payload.return_value': '\{"body": "todo bien"\}'}
        attrs_error = {'code': 404,
                       'payload.return_value': '\{"error": "todo mal"\}'}
        self.api_response = MagicMock()
        self.api_response.configure_mock(**attrs_success)
        self.error_api_response = MagicMock()
        self.error_api_response.configure_mock(**attrs_error)
        self.account = mbm.provider.twitter.Account(
            global_conf, self.conf_file, "twitter")
        self.account.api.statuses.update_with_media = \
            MagicMock(return_value=self.api_response)
        self.account.api.statuses.update = \
            MagicMock(return_value=self.api_response)
        self.real_uuid4 = uuid.uuid4
        uuid.uuid4 = MagicMock(
            return_value='b9b52cfc-fa00-4053-b872-7284272b932d')

    def test_text(self):
        text = mbm.provider.twitter.Text(
            self.account, "title", "body text", "tag1 tag2")
        text.post()
        self.account.api.statuses.update_with_media(
            post_data={'title': 'title', 'body': 'body text',
                       'type': 'text', 'tags': 'tag1 tag2'})
        self.account.api.statuses.update = \
            MagicMock(return_value=self.error_api_response)
        with self.assertRaises(mbm.provider.twitter.TwitterException):
            text.post()
        self.account.api.statuses.update = \
            MagicMock(side_effect=mbm.lib.api.ApiException)
        with self.assertRaises(mbm.provider.twitter.TwitterException):
            text.post()
        self.account.api.statuses.update = \
            MagicMock(return_value=self.api_response)

    def test_model_factory(self):
        with self.assertRaises(mbm.config.AccountException):
            self.account.get_model("NonExistingClass")
        self.assertIs(self.account.get_model("Text"),
                      mbm.provider.twitter.Text)

    def test_token_procurer_url(self):
        self.assertEqual(self.account.token_procurer_url,
                         'http://bob3000.lima-city.de/oauth/token_procurer.'
                         'php?account_type=twitter&consumer_key=CONSUMER_KEY'
                         '&consumer_secret=CONSUMER_SECRET')

    def test_photo(self):
        with self.assertRaises(mbm.provider.twitter.TwitterException):
            mbm.provider.twitter.Photo(self.account, "caption", "link", "tags")
        photo = mbm.provider.twitter.Photo(
            self.account, "caption", "link", "tags",
            data="mbm/tests/fixtures/blue.png")
        photo.post()
        self.account.api.statuses.update_with_media.assert_called_with(
            headers={'Accept-Encoding': 'gzip', 'Content-Type': 'multipar'
                     't/form-data; boundary=#=#Micro-Bog-Magic#=#b9b52cfc'
                     '-fa00-4053-b872-7284272b932d'},
            post_data='--#=#Micro-Bog-Magic#=#b9b52cfc-fa00-4053-b872-7284272b'
            '932d\r\nContent-Disposition: form-data; name="media[]"\r\nContent'
            '-Transfer-Encoding: base64\r\n\r\niVBORw0KGgoAAAANSUhEUgAAAAUAAAA'
            'FCAIAAAACDbGyAAAAFElEQVQImWN0a9rCgASYGFABqXwAdToBhhgbeJgAAAAASUVO'
            'RK5CYII=\r\n--#=#Micro-Bog-Magic#=#b9b52cfc-fa00-4053-b872-728427'
            '2b932d\r\nContent-Disposition: form-data; name="status"\r\n\r\nca'
            'ption\r\n--#=#Micro-Bog-Magic#=#b9b52cfc-fa00-4053-b872-7284272b9'
            '32d--'
            )
        photo = mbm.provider.twitter.Photo(self.account, "caption", "link",
                                           "tags",
                                           data="mbm/tests/fixtures/blue.png")
        photo.post()
        self.account.api.statuses.update_with_media.assert_called_with(
            headers={'Accept-Encoding': 'gzip', 'Content-Type': 'multipar'
                     't/form-data; boundary=#=#Micro-Bog-Magic#=#b9b52cfc'
                     '-fa00-4053-b872-7284272b932d'},
#.........这里部分代码省略.........

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
 def api_login_response(self, status_code, login_status='foo'):
     api_response = MagicMock()
     api_response.configure_mock(status_code=status_code)
     api_response.json = lambda: {'status': login_status}
     return api_response

# 需要导入模块: from unittest.mock import MagicMock [as 别名]
# 或者: from unittest.mock.MagicMock import configure_mock [as 别名]
def squareapi(transaction):
    mock = MagicMock(spec=TransactionApi)
    mock.configure_mock(name="api", **{"return_value.retrieve_transaction.return_value": transaction})
    return mock