def test_making_provider_request():
from testrpc.rpc import RPCMethods
provider = EthereumTesterProvider()
rm = RequestManager(None, provider)
response = rm.request_blocking(method="web3_clientVersion", params=[])
assert response == RPCMethods.web3_clientVersion()
def test_making_provider_request():
from testrpc.rpc import RPCMethods
provider = TestRPCProvider(port=get_open_port())
rm = RequestManager(None, provider)
response = rm.request_blocking(method="web3_clientVersion", params=[])
assert response == RPCMethods.web3_clientVersion()
def __init__(self, providers, middlewares=None, modules=None):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
module_class.attach(self, module_name)
def test_making_provider_request():
from testrpc.rpc import RPCMethods
provider = TheTestRPCProvider(port=get_open_port())
rm = RequestManager(None, provider)
response = rm.request_blocking(method="web3_clientVersion", params=[])
assert response == RPCMethods.web3_clientVersion()
def test_add_duplicate_middleware(middleware_factory):
mw = middleware_factory()
with pytest.raises(ValueError):
manager = RequestManager(None, BaseProvider(), middlewares=[mw, mw])
manager = RequestManager(None, BaseProvider(), middlewares=[])
manager.middleware_stack.add(mw)
with pytest.raises(ValueError):
manager.middleware_stack.add(mw)
assert tuple(manager.middleware_stack) == (mw, )
def test_middleware_holds_state_across_requests():
provider = BaseProvider()
manager = RequestManager(None, provider, middlewares=[stateful_middleware])
state_a = manager.request_blocking('test_statefulness', [])
assert len(state_a) == 1
state_b = manager.request_blocking('test_statefulness', [])
assert id(state_a) == id(state_b)
assert len(state_b) == 2
def test_provider_property_setter_and_getter():
provider = DummyProvider()
manager = RequestManager(None,
provider,
middlewares=[middleware_a, middleware_b])
response = manager.request_blocking('init', ['init'])
assert response['method'] == 'init|middleware-A|middleware-B'
assert response['params'] == ['init', 'middleware-A', 'middleware-B']
assert response['middlewares'] == ['middleware-B', 'middleware-A']
def test_provider_property_setter_and_getter():
provider_a = BaseProvider()
provider_b = BaseProvider()
assert provider_a is not provider_b
manager = RequestManager(None, provider_a)
assert manager.provider is provider_a
manager.provider = provider_b
assert manager.provider is provider_b
def test_provider_property_triggers_regeneration_of_wrapped_middleware():
provider = BaseProvider()
manager = RequestManager(None, provider)
prev_id = id(manager._wrapped_provider_request_functions)
manager.providers = provider
after_id = id(manager._wrapped_provider_request_functions)
assert prev_id != after_id
def __init__(self, providers, middlewares=None, modules=None):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
if hasattr(self, module_name):
raise AttributeError(
"Cannot set web3 module named '{0}'. The web3 object "
"already has an attribute with that name".format(
module_name))
setattr(self, module_name, module_class(self))
def test_provider_property_setter_and_getter(middleware_factory):
provider = BaseProvider()
middleware_a = middleware_factory()
middleware_b = middleware_factory()
middleware_c = middleware_factory()
assert middleware_a is not middleware_b
assert middleware_a is not middleware_c
manager = RequestManager(None, provider, middlewares=[])
assert tuple(manager.middleware_stack) == tuple()
manager.middleware_stack.add(middleware_a)
manager.middleware_stack.add(middleware_b)
manager.middleware_stack.clear()
assert tuple(manager.middleware_stack) == tuple()
manager.middleware_stack.add(middleware_c)
manager.middleware_stack.add(middleware_b)
manager.middleware_stack.add(middleware_a)
with pytest.raises(ValueError):
manager.middleware_stack.add(middleware_b)
assert tuple(manager.middleware_stack) == (
middleware_a,
middleware_b,
middleware_c,
)
def test_add_named_middleware(middleware_factory):
mw = middleware_factory()
manager = RequestManager(None,
BaseProvider(),
middlewares=[(mw, 'the-name')])
assert len(manager.middleware_onion) == 1
assert tuple(manager.middleware_onion) == (mw, )
def test_add_middleware(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
mw3 = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2])
manager.middleware_stack.add(mw3)
assert tuple(manager.middleware_stack) == (mw3, mw1, mw2)
def __init__(self, providers, middlewares=None, modules=None, ens=default):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
module_class.attach(self, module_name)
self.ens = ens
def test_bury_middleware(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
mw3 = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2])
manager.middleware_stack.inject(mw3, layer=0)
assert tuple(manager.middleware_stack) == (mw1, mw2, mw3)
def test_export_middlewares(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
manager = RequestManager(None,
BaseProvider(),
middlewares=[(mw1, 'name1'), (mw2, 'name2')])
assert tuple(manager.middleware_onion) == (mw1, mw2)
middlewares = manager.middleware_onion.middlewares
assert middlewares == [(mw1, 'name1'), (mw2, 'name2')]
def test_add_named_duplicate_middleware(middleware_factory):
mw = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[(mw, 'the-name'), (mw, 'name2')])
assert tuple(manager.middleware_stack) == (mw, mw)
manager.middleware_stack.clear()
assert len(manager.middleware_stack) == 0
manager.middleware_stack.add(mw, 'name1')
manager.middleware_stack.add(mw, 'name2')
assert tuple(manager.middleware_stack) == (mw, mw)
def test_remove_middleware(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
mw3 = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2, mw3])
assert tuple(manager.middleware_stack) == (mw1, mw2, mw3)
manager.middleware_stack.remove(mw2)
assert tuple(manager.middleware_stack) == (mw1, mw3)
def __init__(self,
providers=empty,
middlewares=None,
modules=None,
ens=empty):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
#print("**** Defaulting to middlewares:", modules)
for module_name, module_class in modules.items():
module_class.attach(self, module_name)
self.ens = ens
def test_bury_named_middleware(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
mw3 = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2])
manager.middleware_stack.inject(mw3, name='middleware3', layer=0)
assert tuple(manager.middleware_stack) == (mw1, mw2, mw3)
# make sure middleware was injected with correct name, by trying to remove
# it by name.
manager.middleware_stack.remove('middleware3')
assert tuple(manager.middleware_stack) == (mw1, mw2)
def test_replace_middleware(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
mw3 = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[mw1, (mw2, '2nd'), mw3])
assert tuple(manager.middleware_onion) == (mw1, mw2, mw3)
mw_replacement = middleware_factory()
manager.middleware_onion.replace('2nd', mw_replacement)
assert tuple(manager.middleware_onion) == (mw1, mw_replacement, mw3)
manager.middleware_onion.remove('2nd')
assert tuple(manager.middleware_onion) == (mw1, mw3)
def test_replace_middleware_without_name(middleware_factory):
mw1 = middleware_factory()
mw2 = middleware_factory()
mw3 = middleware_factory()
manager = RequestManager(None, BaseProvider(), middlewares=[mw1, mw2, mw3])
assert tuple(manager.middleware_stack) == (mw1, mw2, mw3)
mw_replacement = middleware_factory()
manager.middleware_stack.replace(mw2, mw_replacement)
assert tuple(manager.middleware_stack) == (mw1, mw_replacement, mw3)
manager.middleware_stack.remove(mw_replacement)
assert tuple(manager.middleware_stack) == (mw1, mw3)
def test_modifying_middleware_regenerates_request_functions():
provider = BaseProvider()
manager = RequestManager(None, provider, middlewares=[])
id_a = id(manager._wrapped_provider_request_functions)
manager.add_middleware(middleware_factory())
id_b = id(manager._wrapped_provider_request_functions)
assert id_b != id_a
manager.clear_middlewares()
id_c = id(manager._wrapped_provider_request_functions)
assert id_b != id_c
class Web3(object):
# Providers
HTTPProvider = HTTPProvider
RPCProvider = RPCProvider
KeepAliveRPCProvider = KeepAliveRPCProvider
IPCProvider = IPCProvider
TestRPCProvider = TestRPCProvider
EthereumTesterProvider = EthereumTesterProvider
# Managers
RequestManager = RequestManager
# Iban
Iban = Iban
# Encoding and Decoding
toBytes = staticmethod(to_bytes)
toDecimal = staticmethod(to_decimal)
toHex = staticmethod(to_hex)
toText = staticmethod(to_text)
# Currency Utility
toWei = staticmethod(to_wei)
fromWei = staticmethod(from_wei)
# Address Utility
isAddress = staticmethod(is_address)
isChecksumAddress = staticmethod(is_checksum_address)
toChecksumAddress = staticmethod(to_checksum_address)
def __init__(self, providers, middlewares=None, modules=None):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
module_class.attach(self, module_name)
def add_middleware(self, middleware):
"""
Convenience API for RequestManager.add_middleware
"""
self.manager.add_middleware(middleware)
def clear_middlewares(self):
"""
Convenience API for RequestManager.clear_middlewares
"""
self.manager.clear_middlewares()
@property
def providers(self):
return self.manager.providers
def setProviders(self, providers):
self.manager.setProvider(providers)
@deprecated_for("the `manager` attribute")
def setManager(self, manager):
self.manager = manager
@property
@deprecated_for("`providers`, which is now a list")
def currentProvider(self):
return self.manager.providers[0]
@staticmethod
@apply_to_return_value(encode_hex)
def sha3(primitive=None, text=None, hexstr=None, encoding=None):
if encoding is not None:
warnings.warn(
DeprecationWarning(
"The encoding keyword has been deprecated. Please update your "
"code to use sha3(text='txt'), sha3(hexstr='0x747874'), "
"sha3(b'\\x74\\x78\\x74'), or sha3(0x747874)."))
elif not isinstance(primitive, (bytes, int, type(None))):
warnings.warn(
DeprecationWarning(
"The first argument as a string has been deprecated. Please update your "
"code to use sha3(text='txt'), sha3(hexstr='0x747874'), "
"sha3(b'\\x74\\x78\\x74'), or sha3(0x747874)."))
args = (arg for arg in (primitive, text, hexstr) if arg is not None)
if len(list(args)) != 1:
raise TypeError(
"Only supply one positional arg, or the text, or hexstr keyword args. "
"You supplied %r and %r" % (primitive, {
'text': text,
'hexstr': hexstr
}))
if isinstance(primitive, bytes) and bytes == str:
# *shakes fist at python 2*
# fall back to deprecated functionality
pass
elif isinstance(
primitive,
(bytes, int)) or text is not None or hexstr is not None:
input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
return keccak(input_bytes)
# handle deprecated cases
if encoding in ('hex', None):
return keccak(decode_hex(primitive))
elif encoding == 'bytes':
return keccak(primitive)
elif encoding == 'utf8':
return keccak(primitive.encode('utf8'))
raise TypeError(
"You called sha3 with first arg %r and keywords %r. You must call it with one of "
"these approaches: sha3(text='txt'), sha3(hexstr='0x747874'), "
"sha3(b'\\x74\\x78\\x74'), or sha3(0x747874)." % (primitive, {
'encoding': encoding,
'text': text,
'hexstr': hexstr
}))
def soliditySha3(self, abi_types, values):
"""
Executes sha3 (keccak256) exactly as Solidity does.
Takes list of abi_types as inputs -- `[uint24, int8[], bool]`
and list of corresponding values -- `[20, [-1, 5, 0], True]`
"""
if len(abi_types) != len(values):
raise ValueError(
"Length mismatch between provided abi types and values. Got "
"{0} types and {1} values.".format(len(abi_types),
len(values)))
hex_string = add_0x_prefix(''.join(
remove_0x_prefix(hex_encode_abi_type(abi_type, value))
for abi_type, value in zip(abi_types, values)))
return self.sha3(hexstr=hex_string)
def isConnected(self):
for provider in self.providers:
if provider.isConnected():
return True
else:
return False
@staticmethod
@deprecated_for("toBytes()")
def toAscii(val):
return decode_hex(val)
@staticmethod
@deprecated_for("toHex()")
def fromAscii(val):
return encode_hex(val)
@staticmethod
@deprecated_for("toText()")
def toUtf8(val):
return force_text(decode_hex(val))
@staticmethod
@deprecated_for("toHex()")
def fromUtf8(string):
return encode_hex(string)
@staticmethod
@deprecated_for("toHex()")
def fromDecimal(decimal):
return from_decimal(decimal)
class Web3(object):
# Providers
HTTPProvider = HTTPProvider
IPCProvider = IPCProvider
TestRPCProvider = TestRPCProvider
EthereumTesterProvider = EthereumTesterProvider
# Managers
RequestManager = RequestManager
# Iban
Iban = Iban
# Encoding and Decoding
toBytes = staticmethod(to_bytes)
toInt = staticmethod(to_int)
toHex = staticmethod(to_hex)
toText = staticmethod(to_text)
# Currency Utility
toWei = staticmethod(to_wei)
fromWei = staticmethod(from_wei)
# Address Utility
isAddress = staticmethod(is_address)
isChecksumAddress = staticmethod(is_checksum_address)
toChecksumAddress = staticmethod(to_checksum_address)
def __init__(self, providers, middlewares=None, modules=None):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
module_class.attach(self, module_name)
@property
def middleware_stack(self):
return self.manager.middleware_stack
@property
def providers(self):
return self.manager.providers
def setProviders(self, providers):
self.manager.setProvider(providers)
@staticmethod
@apply_to_return_value(HexBytes)
def sha3(primitive=None, text=None, hexstr=None):
if isinstance(primitive, (bytes, int, type(None))):
input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
return keccak(input_bytes)
raise TypeError(
"You called sha3 with first arg %r and keywords %r. You must call it with one of "
"these approaches: sha3(text='txt'), sha3(hexstr='0x747874'), "
"sha3(b'\\x74\\x78\\x74'), or sha3(0x747874)." % (primitive, {
'text': text,
'hexstr': hexstr
}))
@classmethod
def soliditySha3(cls, abi_types, values):
"""
Executes sha3 (keccak256) exactly as Solidity does.
Takes list of abi_types as inputs -- `[uint24, int8[], bool]`
and list of corresponding values -- `[20, [-1, 5, 0], True]`
"""
if len(abi_types) != len(values):
raise ValueError(
"Length mismatch between provided abi types and values. Got "
"{0} types and {1} values.".format(len(abi_types),
len(values)))
hex_string = add_0x_prefix(''.join(
remove_0x_prefix(hex_encode_abi_type(abi_type, value))
for abi_type, value in zip(abi_types, values)))
return cls.sha3(hexstr=hex_string)
def isConnected(self):
for provider in self.providers:
if provider.isConnected():
return True
else:
return False
class Web3(object):
# Providers
HTTPProvider = HTTPProvider
RPCProvider = RPCProvider
KeepAliveRPCProvider = KeepAliveRPCProvider
IPCProvider = IPCProvider
TestRPCProvider = TestRPCProvider
EthereumTesterProvider = EthereumTesterProvider
# Managers
RequestManager = RequestManager
# Iban
Iban = Iban
# Encoding and Decoding
toHex = staticmethod(to_hex)
toAscii = staticmethod(decode_hex)
toUtf8 = staticmethod(compose(force_text, decode_hex))
fromAscii = staticmethod(encode_hex)
fromUtf8 = staticmethod(encode_hex)
toDecimal = staticmethod(to_decimal)
fromDecimal = staticmethod(from_decimal)
# Currency Utility
toWei = staticmethod(to_wei)
fromWei = staticmethod(from_wei)
# Address Utility
isAddress = staticmethod(is_address)
isChecksumAddress = staticmethod(is_checksum_address)
toChecksumAddress = staticmethod(to_checksum_address)
def __init__(self, providers, middlewares=None, modules=None):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
if hasattr(self, module_name):
raise AttributeError(
"Cannot set web3 module named '{0}'. The web3 object "
"already has an attribute with that name".format(
module_name))
setattr(self, module_name, module_class(self))
def add_middleware(self, middleware):
"""
Convenience API for RequestManager.add_middleware
"""
self.manager.add_middleware(middleware)
def clear_middlewares(self):
"""
Convenience API for RequestManager.clear_middlewares
"""
self.manager.clear_middlewares()
@property
def providers(self):
return self.manager.providers
def setProviders(self, providers):
self.manager.setProvider(providers)
def setManager(self, manager):
warnings.warn(
DeprecationWarning(
"The `setManager` method has been deprecated. Please update your "
"code to directly set the `manager` property."))
self.manager = manager
@property
def currentProvider(self):
warnings.warn(
DeprecationWarning(
"The `currentProvider` property has been renamed to `providers` and is now a list."
))
return self.manager.providers[0]
@coerce_return_to_text
def sha3(self, value, encoding="hex"):
if encoding == 'hex':
hex_string = value
else:
hex_string = encode_hex(value)
return self.manager.request_blocking('web3_sha3', [hex_string])
def soliditySha3(self, abi_types, values):
"""
Executes sha3 (keccak256) exactly as Solidity does.
Takes list of abi_types as inputs -- `[uint24, int8[], bool]`
and list of corresponding values -- `[20, [-1, 5, 0], True]`
"""
if len(abi_types) != len(values):
raise ValueError(
"Length mismatch between provided abi types and values. Got "
"{0} types and {1} values.".format(len(abi_types),
len(values)))
hex_string = add_0x_prefix(''.join(
remove_0x_prefix(hex_encode_abi_type(abi_type, value))
for abi_type, value in zip(abi_types, values)))
return self.sha3(hex_string, encoding="hex")
def isConnected(self):
for provider in self.providers:
if provider.isConnected():
return True
else:
return False
class Web3(object):
# Providers
HTTPProvider = HTTPProvider
RPCProvider = RPCProvider
KeepAliveRPCProvider = KeepAliveRPCProvider
IPCProvider = IPCProvider
TestRPCProvider = TestRPCProvider
EthereumTesterProvider = EthereumTesterProvider
# Managers
RequestManager = RequestManager
# Iban
Iban = Iban
# Encoding and Decoding
toHex = staticmethod(to_hex)
toAscii = staticmethod(decode_hex)
toUtf8 = staticmethod(compose(force_text, decode_hex))
fromAscii = staticmethod(encode_hex)
fromUtf8 = staticmethod(encode_hex)
toDecimal = staticmethod(to_decimal)
fromDecimal = staticmethod(from_decimal)
# Currency Utility
toWei = staticmethod(to_wei)
fromWei = staticmethod(from_wei)
# Address Utility
isAddress = staticmethod(is_address)
isChecksumAddress = staticmethod(is_checksum_address)
toChecksumAddress = staticmethod(to_checksum_address)
def __init__(self, providers, middlewares=None, modules=None):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
if hasattr(self, module_name):
raise AttributeError(
"Cannot set web3 module named '{0}'. The web3 object "
"already has an attribute with that name".format(
module_name))
setattr(self, module_name, module_class(self))
@property
def providers(self):
return self.manager.providers
def setProviders(self, providers):
self.manager.setProvider(providers)
def setManager(self, manager):
warnings.warn(
DeprecationWarning(
"The `setManager` method has been deprecated. Please update your "
"code to directly set the `manager` property."))
self.manager = manager
@property
def currentProvider(self):
warnings.warn(
DeprecationWarning(
"The `currentProvider` property has been renamed to `providers` and is now a list."
))
return self.manager.providers[0]
@coerce_return_to_text
def sha3(self, value, encoding="hex"):
if encoding == 'hex':
hex_string = value
else:
hex_string = encode_hex(value)
return self.manager.request_blocking('web3_sha3', [hex_string])
def isConnected(self):
for provider in self.providers:
if provider.isConnected():
return True
else:
return False
class Web3(object):
# Providers
HTTPProvider = HTTPProvider
IPCProvider = IPCProvider
TestRPCProvider = TestRPCProvider
EthereumTesterProvider = EthereumTesterProvider
# Managers
RequestManager = RequestManager
# Iban
Iban = Iban
# Encoding and Decoding
toBytes = staticmethod(to_bytes)
toInt = staticmethod(to_int)
toHex = staticmethod(to_hex)
toText = staticmethod(to_text)
# Currency Utility
toWei = staticmethod(to_wei)
fromWei = staticmethod(from_wei)
# Address Utility
isAddress = staticmethod(is_address)
isChecksumAddress = staticmethod(is_checksum_address)
toChecksumAddress = staticmethod(to_checksum_address)
def __init__(self, providers, middlewares=None, modules=None, ens=default):
self.manager = RequestManager(self, providers, middlewares)
if modules is None:
modules = get_default_modules()
for module_name, module_class in modules.items():
module_class.attach(self, module_name)
self.ens = ens
@property
def middleware_stack(self):
return self.manager.middleware_stack
@property
def providers(self):
return self.manager.providers
def setProviders(self, providers):
self.manager.setProvider(providers)
@staticmethod
@apply_to_return_value(HexBytes)
def sha3(primitive=None, text=None, hexstr=None):
if isinstance(primitive, (bytes, int, type(None))):
input_bytes = to_bytes(primitive, hexstr=hexstr, text=text)
return keccak(input_bytes)
raise TypeError(
"You called sha3 with first arg %r and keywords %r. You must call it with one of "
"these approaches: sha3(text='txt'), sha3(hexstr='0x747874'), "
"sha3(b'\\x74\\x78\\x74'), or sha3(0x747874)." % (
primitive,
{'text': text, 'hexstr': hexstr}
)
)
@combomethod
def soliditySha3(cls, abi_types, values):
"""
Executes sha3 (keccak256) exactly as Solidity does.
Takes list of abi_types as inputs -- `[uint24, int8[], bool]`
and list of corresponding values -- `[20, [-1, 5, 0], True]`
"""
if len(abi_types) != len(values):
raise ValueError(
"Length mismatch between provided abi types and values. Got "
"{0} types and {1} values.".format(len(abi_types), len(values))
)
if isinstance(cls, type):
w3 = None
else:
w3 = cls
normalized_values = map_abi_data([abi_ens_resolver(w3)], abi_types, values)
hex_string = add_0x_prefix(''.join(
remove_0x_prefix(hex_encode_abi_type(abi_type, value))
for abi_type, value
in zip(abi_types, normalized_values)
))
return cls.sha3(hexstr=hex_string)
def isConnected(self):
for provider in self.providers:
if provider.isConnected():
return True
else:
return False
@property
def ens(self):
if self._ens is default:
return ENS.fromWeb3(self)
else:
return self._ens
@ens.setter
def ens(self, new_ens):
self._ens = new_ens
def test_setProvider_api_deprecation():
manager = RequestManager(None, BaseProvider())
with pytest.warns(DeprecationWarning):
manager.setProvider(BaseProvider())
def test_provider_property_setter_and_getter():
provider = BaseProvider()
middleware_a = middleware_factory()
middleware_b = middleware_factory()
assert middleware_a is not middleware_b
manager = RequestManager(None, provider, middlewares=[])
assert manager.middlewares == tuple()
manager.add_middleware(middleware_a)
manager.add_middleware(middleware_b)
manager.clear_middlewares()
assert manager.middlewares == tuple()
manager.add_middleware(middleware_b)
manager.add_middleware(middleware_a)
manager.add_middleware(middleware_b)
manager.add_middleware(middleware_b)
manager.add_middleware(middleware_a)
assert manager.middlewares == (
middleware_a,
middleware_b,
middleware_b,
middleware_a,
middleware_b,
)
