def test_protocol_instance_caching(self, m):
# Verify that we get the same Protocol instance for the same combination of (endpoint, credentials)
user, password = get_random_string(8), get_random_string(8)
config = Configuration(service_endpoint='https://example.com/Foo.asmx',
credentials=Credentials(user, password),
auth_type=NTLM,
version=Version(Build(15, 1)),
retry_policy=FailFast())
# Test CachingProtocol.__getitem__
with self.assertRaises(KeyError):
_ = Protocol[config]
base_p = Protocol(config=config)
self.assertEqual(base_p, Protocol[config][0])
# Make sure we always return the same item when creating a Protocol with the same endpoint and creds
for _ in range(10):
p = Protocol(config=config)
self.assertEqual(base_p, p)
self.assertEqual(id(base_p), id(p))
self.assertEqual(hash(base_p), hash(p))
self.assertEqual(id(base_p._session_pool), id(p._session_pool))
# Test CachingProtocol.__delitem__
del Protocol[config]
with self.assertRaises(KeyError):
_ = Protocol[config]
# Make sure we get a fresh instance after we cleared the cache
p = Protocol(config=config)
self.assertNotEqual(base_p, p)
Protocol.clear_cache()
def test_session(self, m):
protocol = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx',
credentials=Credentials(get_random_string(8), get_random_string(8)),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
session = protocol.create_session()
new_session = protocol.renew_session(session)
self.assertNotEqual(id(session), id(new_session))
def test_session(self, m):
m.get('https://example.com/EWS/types.xsd', status_code=200)
protocol = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx', credentials=Credentials('A', 'B'),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
session = protocol.create_session()
new_session = protocol.renew_session(session)
self.assertNotEqual(id(session), id(new_session))
def test_init(self):
with self.assertRaises(TypeError) as e:
Protocol(config="XXX")
self.assertEqual(
e.exception.args[0],
"'config' 'XXX' must be of type <class 'exchangelib.configuration.Configuration'>"
)
with self.assertRaises(AttributeError) as e:
Protocol(config=Configuration())
self.assertEqual(e.exception.args[0],
"'config.service_endpoint' must be set")
def test_decrease_poolsize(self):
protocol = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx', credentials=Credentials('A', 'B'),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
self.assertEqual(protocol._session_pool.qsize(), Protocol.SESSION_POOLSIZE)
protocol.decrease_poolsize()
self.assertEqual(protocol._session_pool.qsize(), 3)
protocol.decrease_poolsize()
self.assertEqual(protocol._session_pool.qsize(), 2)
protocol.decrease_poolsize()
self.assertEqual(protocol._session_pool.qsize(), 1)
with self.assertRaises(SessionPoolMinSizeReached):
protocol.decrease_poolsize()
self.assertEqual(protocol._session_pool.qsize(), 1)
def test_protocol_instance_caching(self, m):
# Verify that we get the same Protocol instance for the same combination of (endpoint, credentials)
m.get('https://example.com/EWS/types.xsd', status_code=200)
base_p = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx', credentials=Credentials('A', 'B'),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
for i in range(10):
p = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx', credentials=Credentials('A', 'B'),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
self.assertEqual(base_p, p)
self.assertEqual(id(base_p), id(p))
self.assertEqual(hash(base_p), hash(p))
self.assertEqual(id(base_p._session_pool), id(p._session_pool))
def test_close(self):
proc = psutil.Process()
ip_addresses = {
info[4][0]
for info in
socket.getaddrinfo('example.com', 80, socket.AF_INET,
socket.SOCK_DGRAM, socket.IPPROTO_IP)
}
self.assertGreater(len(ip_addresses), 0)
protocol = Protocol(
config=Configuration(service_endpoint='http://example.com',
credentials=Credentials('A', 'B'),
auth_type=NOAUTH,
version=Version(Build(15, 1)),
retry_policy=FailFast()))
session = protocol.get_session()
session.get('http://example.com')
self.assertEqual(
len({
p.raddr[0]
for p in proc.connections() if p.raddr[0] in ip_addresses
}), 1)
protocol.release_session(session)
protocol.close()
self.assertEqual(
len({
p.raddr[0]
for p in proc.connections() if p.raddr[0] in ip_addresses
}), 0)
def test_protocol_instance_caching(self, m):
# Verify that we get the same Protocol instance for the same combination of (endpoint, credentials)
user, password = get_random_string(8), get_random_string(8)
base_p = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx', credentials=Credentials(user, password),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
for _ in range(10):
p = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx', credentials=Credentials(user, password),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
self.assertEqual(base_p, p)
self.assertEqual(id(base_p), id(p))
self.assertEqual(hash(base_p), hash(p))
self.assertEqual(id(base_p._session_pool), id(p._session_pool))
Protocol.clear_cache()
def test_pickle(self):
# Test that we can pickle, repr and str Protocols
o = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx',
credentials=Credentials(get_random_string(8), get_random_string(8)),
auth_type=NTLM, version=Version(Build(15, 1)), retry_policy=FailFast()
))
pickled_o = pickle.dumps(o)
unpickled_o = pickle.loads(pickled_o)
self.assertIsInstance(unpickled_o, type(o))
self.assertEqual(repr(o), repr(unpickled_o))
self.assertEqual(str(o), str(unpickled_o))
def get_test_protocol(**kwargs):
return Protocol(config=Configuration(
server=kwargs.get("server"),
service_endpoint=kwargs.get(
"service_endpoint",
f"https://{get_random_hostname()}/Foo.asmx"),
credentials=kwargs.get(
"credentials",
Credentials(get_random_string(8), get_random_string(8))),
auth_type=kwargs.get("auth_type", NTLM),
version=kwargs.get("version", Version(Build(15, 1))),
retry_policy=kwargs.get("retry_policy", FailFast()),
max_connections=kwargs.get("max_connections"),
))
def test_close(self):
# Don't use example.com here - it does not resolve or answer on all ISPs
proc = psutil.Process()
ip_addresses = {
info[4][0]
for info in
socket.getaddrinfo('httpbin.org', 80, socket.AF_INET,
socket.SOCK_DGRAM, socket.IPPROTO_IP)
}
def conn_count():
return len(
[p for p in proc.connections() if p.raddr[0] in ip_addresses])
self.assertGreater(len(ip_addresses), 0)
protocol = Protocol(config=Configuration(
service_endpoint='http://httpbin.org',
credentials=Credentials(get_random_string(8), get_random_string(
8)),
auth_type=NOAUTH,
version=Version(Build(15, 1)),
retry_policy=FailFast(),
max_connections=3))
# Merely getting a session should not create conections
session = protocol.get_session()
self.assertEqual(conn_count(), 0)
# Open one URL - we have 1 connection
session.get('http://httpbin.org')
self.assertEqual(conn_count(), 1)
# Open the same URL - we should still have 1 connection
session.get('http://httpbin.org')
self.assertEqual(conn_count(), 1)
# Open some more connections
s2 = protocol.get_session()
s2.get('http://httpbin.org')
s3 = protocol.get_session()
s3.get('http://httpbin.org')
self.assertEqual(conn_count(), 3)
# Releasing the sessions does not close the connections
protocol.release_session(session)
protocol.release_session(s2)
protocol.release_session(s3)
self.assertEqual(conn_count(), 3)
# But closing explicitly does
protocol.close()
self.assertEqual(conn_count(), 0)
def test_decrease_poolsize(self):
# Test increasing and decreasing the pool size
max_connections = 3
protocol = Protocol(config=Configuration(
service_endpoint='https://example.com/Foo.asmx',
credentials=Credentials(get_random_string(8), get_random_string(
8)),
auth_type=NTLM,
version=Version(Build(15, 1)),
retry_policy=FailFast(),
max_connections=max_connections,
))
self.assertEqual(protocol._session_pool.qsize(), 0)
self.assertEqual(protocol.session_pool_size, 0)
protocol.increase_poolsize()
protocol.increase_poolsize()
protocol.increase_poolsize()
with self.assertRaises(SessionPoolMaxSizeReached):
protocol.increase_poolsize()
self.assertEqual(protocol._session_pool.qsize(), max_connections)
self.assertEqual(protocol.session_pool_size, max_connections)
protocol.decrease_poolsize()
protocol.decrease_poolsize()
with self.assertRaises(SessionPoolMinSizeReached):
protocol.decrease_poolsize()
self.assertEqual(protocol._session_pool.qsize(), 1)