def test_assign_list_of_named_addresses(self):
addresses = [('Test User 1', '*****@*****.**'), ('Test User 2', '*****@*****.**')]
self.addresses = addresses
string_addresses = [unicode(Address(*value)) for value in addresses]
eq_(', '.join(string_addresses), unicode(self.addresses))
eq_(string_addresses, self.addresses)
def test_request(self):
response = self.request(protocol=b"HTTP/1.0")
request = eval(response.body)
expect = {
"CONTENT_LENGTH": None,
"CONTENT_TYPE": None,
"FRAGMENT": "",
"HTTP_HOST": "localhost",
"PARAMETERS": unicode(),
"PATH_INFO": b"/".decode("iso-8859-1"),
"QUERY_STRING": unicode(),
"REMOTE_ADDR": "127.0.0.1",
"REQUEST_METHOD": "GET",
"SCRIPT_NAME": unicode(),
"SERVER_ADDR": "127.0.0.1",
"SERVER_PROTOCOL": "HTTP/1.0",
"wsgi.multiprocess": False,
"wsgi.multithread": False,
"wsgi.run_once": False,
"wsgi.url_scheme": "http",
"wsgi.version": (2, 0),
"REQUEST_URI": b"/",
"wsgi.async": False,
"wsgi.uri_encoding": "utf8",
}
self.assertEquals(request, expect)
def test_assign_list_of_named_addresses(self):
addresses = [('Test User 1', '*****@*****.**'), ('Test User 2', '*****@*****.**')]
self.addresses = addresses
string_addresses = [unicode(Address(*value)) for value in addresses]
assert ', '.join(string_addresses) == unicode(self.addresses)
assert string_addresses == self.addresses
def test_callable_bodies(self):
message = self.build_message()
message.plain = lambda: "plain text"
message.rich = lambda: "rich text"
assert 'plain text' in unicode(message)
assert 'rich text' in unicode(message)
def test_callable_bodies(self): message = self.build_message() message.plain = lambda: "plain text" message.rich = lambda: "rich text" assert 'plain text' in unicode(message) assert 'rich text' in unicode(message)
def test_chunked(self):
response = self.request()
self.assertEquals(response.protocol, b"HTTP/1.1")
self.assertEquals(response.code, b"200")
self.assertEquals(response.status, b"OK")
self.assertEquals(response[b'content-type'], b"text/plain; charset=utf8")
self.assertEquals(response[b'transfer-encoding'], b"chunked")
request = eval(response.body)
expect = {
'CONTENT_LENGTH': None,
'CONTENT_TYPE': None,
'FRAGMENT': '',
'HTTP_HOST': 'localhost',
'PARAMETERS': unicode(),
'PATH_INFO': b'/'.decode('iso-8859-1'),
'QUERY_STRING': unicode(),
'REMOTE_ADDR': '127.0.0.1',
'REQUEST_METHOD': 'GET',
'SCRIPT_NAME': unicode(),
'SERVER_ADDR': '127.0.0.1',
'SERVER_PROTOCOL': 'HTTP/1.1',
'wsgi.multiprocess': False,
'wsgi.multithread': False,
'wsgi.run_once': False,
'wsgi.url_scheme': 'http',
'wsgi.version': (2, 0),
'REQUEST_URI': b'http://localhost/',
'wsgi.async': False,
'wsgi.uri_encoding': 'utf8'
}
self.assertEquals(request, expect)
def echo(chunked, request):
prune(request, True)
result = unicode(pformat(request)).encode('utf8')
headers = [(b'Content-Type', b'text/plain; charset=utf8')]
if not chunked:
headers.append((b'Content-Length', unicode(len(result)).encode('ascii')))
return b'200 OK', headers, (result.split(b"\n") if chunked else [result])
def test_mime_generation_rich_embedded(self):
message = self.build_message()
message.plain = "Hello world."
message.rich = "Farewell cruel world."
message.attach("hello.txt", b"Fnord.", "text", "plain", True)
assert 'Hello world.' in unicode(message)
assert 'Farewell cruel world.' in unicode(message)
assert 'hello.txt' in unicode(message)
assert 'Rm5vcmQu' in unicode(message) # Fnord. in base64
def test_mime_generation_rich_embedded(self):
message = self.build_message()
message.plain = "Hello world."
message.rich = "Farewell cruel world."
message.attach("hello.txt", b"Fnord.", "text", "plain", True)
assert 'Hello world.' in unicode(message)
assert 'Farewell cruel world.' in unicode(message)
assert 'hello.txt' in unicode(message)
assert 'Rm5vcmQu' in unicode(message) # Fnord. in base64
def test_mime_attachments(self):
message = self.build_message()
message.plain = "Hello world."
message.rich = "Farewell cruel world."
message.attach("hello.txt", b"Fnord.")
assert 'Hello world.' in unicode(message)
assert 'Farewell cruel world.' in unicode(message)
assert 'hello.txt' in unicode(message)
assert 'Rm5vcmQu' in unicode(message) # Fnord. in base64
assert 'text/plain\n' in unicode(message)
def test_mime_attachments(self):
message = self.build_message()
message.plain = "Hello world."
message.rich = "Farewell cruel world."
message.attach("hello.txt", b"Fnord.")
assert 'Hello world.' in unicode(message)
assert 'Farewell cruel world.' in unicode(message)
assert 'hello.txt' in unicode(message)
assert 'Rm5vcmQu' in unicode(message) # Fnord. in base64
assert 'text/plain\n' in unicode(message)
def test_language_specification_but_no_charset_for_attachment_name(self):
message = self.build_message()
message.plain = "Hello world."
message.rich = "Farewell cruel world."
message.attach("☃.txt", b"unicode snowman", filename_language='en-us')
assert 'Hello world.' in unicode(message)
assert 'Farewell cruel world.' in unicode(message)
if sys.version_info < (3, 0):
assert 'filename*="utf-8\'en-us\'%E2%98%83.txt"' in unicode(message) # ☃ is encoded in ASCII as \xe2\x98\x83, which is URL encoded as %E2%98%83
else:
assert 'filename*=utf-8\'en-us\'%E2%98%83.txt' in unicode(message) # ☃ is encoded in ASCII as \xe2\x98\x83, which is URL encoded as %E2%98%83
assert 'dW5pY29kZSBzbm93bWFu' in unicode(message) # unicode snowman in base64
def test_language_specification_but_no_charset_for_attachment_name(self):
message = self.build_message()
message.plain = "Hello world."
message.rich = "Farewell cruel world."
message.attach("☃.txt", b"unicode snowman", filename_language='en-us')
assert 'Hello world.' in unicode(message)
assert 'Farewell cruel world.' in unicode(message)
if sys.version_info < (3, 0):
assert 'filename*="utf-8\'en-us\'%E2%98%83.txt"' in unicode(message) # ☃ is encoded in ASCII as \xe2\x98\x83, which is URL encoded as %E2%98%83
else:
assert 'filename*=utf-8\'en-us\'%E2%98%83.txt' in unicode(message) # ☃ is encoded in ASCII as \xe2\x98\x83, which is URL encoded as %E2%98%83
assert 'dW5pY29kZSBzbm93bWFu' in unicode(message) # unicode snowman in base64
def render(self, safe=False):
parts = []
parts.append((self.scheme + "://") if self.scheme else "")
parts.append(self.user or "")
parts.append((":" + self.password) if self.user else ("@" if self.user else ""))
parts.append(self.host or "")
parts.append((":" + str(self.port)) if self.port else "")
parts.append(unicode(self.path) or "/")
parts.append((";" + unicode(self.params)) if self.params else "")
parts.append(("?" + unicode(self.query)) if self.query else "")
parts.append(("#" + quote_plus(self.fragment)) if self.fragment else "")
return "".join(parts)
def render(self, safe=False):
parts = []
parts.append((self.scheme + "://") if self.scheme else "")
parts.append(self.user or "")
parts.append((":" + self.password) if self.user else (
"@" if self.user else ""))
parts.append(self.host or "")
parts.append((":" + str(self.port)) if self.port else "")
parts.append(unicode(self.path) or "/")
parts.append((";" + unicode(self.params)) if self.params else "")
parts.append(("?" + unicode(self.query)) if self.query else "")
parts.append(("#" +
quote_plus(self.fragment)) if self.fragment else "")
return "".join(parts)
def __init__(self, server, protocol, client):
self.server = server
self.protocol = protocol
self.client = client
env = dict()
env['REMOTE_ADDR'] = client.address[0]
env['SERVER_NAME'] = protocol._name
env['SERVER_ADDR'] = protocol._addr
env['SERVER_PORT'] = protocol._port
env['SCRIPT_NAME'] = unicode()
env['wsgi.input'] = IO()
env['wsgi.errors'] = errorlog
env['wsgi.version'] = (2, 0)
env['wsgi.multithread'] = getattr(server, 'threaded', False) # TODO: Temporary hack until marrow.server 1.0 release.
env['wsgi.multiprocess'] = server.fork != 1
env['wsgi.run_once'] = False
env['wsgi.url_scheme'] = 'http'
env['wsgi.async'] = False # TODO
if self.server.threaded is not False:
env['wsgi.executor'] = self.server.executor # pimp out the concurrent.futures thread pool executor
# env['wsgi.script_name'] = b''
# env['wsgi.path_info'] = b''
self.environ = None
self.environ_template = env
self.finished = False
self.pipeline = protocol.options.get('pipeline', True) # TODO
client.read_until(dCRLF, self.headers)
def __init__(self, name_or_email, email=None, encoding='utf-8'):
if email is None:
if isinstance(name_or_email, AddressList):
if not 0 < len(name_or_email) < 2:
raise ValueError("AddressList to convert must only contain a single Address.")
name_or_email = unicode(name_or_email[0])
if isinstance(name_or_email, (tuple, list)):
self.name = unicodestr(name_or_email[0], encoding)
self.address = unicodestr(name_or_email[1], encoding)
elif isinstance(name_or_email, bytes):
self.name, self.address = parseaddr(unicodestr(name_or_email, encoding))
elif isinstance(name_or_email, unicode):
self.name, self.address = parseaddr(name_or_email)
else:
raise TypeError('Expected string, tuple or list, got {0} instead'.format(
repr(type(name_or_email))
))
else:
self.name = unicodestr(name_or_email, encoding)
self.address = unicodestr(email, encoding)
email, err = EmailValidator().validate_email(self.address)
if err:
raise ValueError('"{0}" is not a valid e-mail address: {1}'.format(email, err))
def __call__(self, request):
result = b"Hello " + self.name + b"!"
return b'200 OK', [
(b'Content-Type', b'text/plain; charset=utf8'),
(b'Content-Length', unicode(len(result)).encode('ascii'))
], [result]
def test_can_set_encoding_for_message_explicitely(self):
message = self.build_message()
assert 'iso-8859-1' not in unicode(message).lower()
message.encoding = 'ISO-8859-1'
msg = email.message_from_string(str(message))
assert msg['Content-Type'] == 'text/plain; charset="iso-8859-1"'
assert msg['Content-Transfer-Encoding'] == 'quoted-printable'
def test_can_set_encoding_for_message_explicitely(self): message = self.build_message() assert 'iso-8859-1' not in unicode(message).lower() message.encoding = 'ISO-8859-1' msg = email.message_from_string(str(message)) assert msg['Content-Type'] == 'text/plain; charset="iso-8859-1"' assert msg['Content-Transfer-Encoding'] == 'quoted-printable'
def __init__(self, value=None, separator='/', encoded=False):
self.separator = unicode(separator)
super(Path, self).__init__()
if value is not None:
self._assign(value, encoded)
def __init__(self, value=None, separator='/', encoded=False):
self.separator = unicode(separator)
super(Path, self).__init__()
if value is not None:
self._assign(value, encoded)
def test_path_slicing(self):
class MockOb(object):
path = Path()
instance = MockOb()
instance.path = '/foo/bar/baz'
self.assertEqual(unicode(instance.path[1:]), unicode('foo/bar/baz'))
self.assertEqual(unicode(instance.path[2:]), unicode('bar/baz'))
self.assertEqual(unicode(instance.path[0:2]), unicode('/foo'))
self.assertEqual(unicode(instance.path[::2]), unicode('/bar'))
def mock_headers(self, length=None, disable=False, mime=b"text/plain"):
headers = [(b'Content-Type', mime)] if mime else []
if length is not None:
headers.append((b'Content-Length', unicode(length).encode('ascii')))
if disable:
headers.append((b'Content-Encoding', b'mock'))
return headers
def test_path_slicing(self):
class MockOb(object):
path = Path()
instance = MockOb()
instance.path = '/foo/bar/baz'
self.assertEqual(unicode(instance.path[1:]), unicode('foo/bar/baz'))
self.assertEqual(unicode(instance.path[2:]), unicode('bar/baz'))
self.assertEqual(unicode(instance.path[0:2]), unicode('/foo'))
self.assertEqual(unicode(instance.path[::2]), unicode('/bar'))
def _add_headers_to_message(self, message, headers): for header in headers: if header[1] is None or (isinstance(header[1], list) and not header[1]): continue name, value = header if isinstance(value, (Address, AddressList)): value = unicode(value) message[name] = value
def _assign(self, value, encoded=False):
self.clear()
if value is None:
return
if isinstance(value, (binary, unicode)):
self.extend((unquote_plus(i) if encoded else i) for i in unicode(value).split(self.separator))
return
self.extend(value)
def _add_headers_to_message(self, message, headers): for header in headers: if header[1] is None or (isinstance(header[1], list) and not header[1]): continue name, value = header if isinstance(value, (Address, AddressList)): value = unicode(value) message[name] = value
def _assign(self, value, encoded=False):
self.clear()
if value is None:
return
if isinstance(value, (binary, unicode)):
self.extend((unquote_plus(i) if encoded else i)
for i in unicode(value).split(self.separator))
return
self.extend(value)
def body_echo(request):
prune(request, True)
if 'wsgi.input' not in request:
request['wsgi.input'] = b""
headers = [(b'Content-Type', b'text/plain; charset=utf8')]
if 'HTTP_CONTENT_LENGTH' in request:
headers.append((b'Content-Length', unicode(len(request['wsgi.input'])).encode('ascii')))
return b'200 OK', headers, [request['wsgi.input']]
def __eq__(self, other):
if isinstance(other, Address):
return (self.name, self.address) == (other.name, other.address)
elif isinstance(other, unicode):
return unicode(self) == other
elif isinstance(other, bytes):
return bytes(self) == other
elif isinstance(other, tuple):
return (self.name, self.address) == other
raise NotImplementedError("Can not compare Address instance against {0} instance".format(type(other)))
def test_missing_values(self): message = Message() with pytest.raises(ValueError): unicode(message) message.author = "*****@*****.**" with pytest.raises(ValueError): unicode(message) message.subject = "Attn: Bob Dole" with pytest.raises(ValueError): unicode(message) message.to = "*****@*****.**" with pytest.raises(ValueError): unicode(message) message.plain = "Testing!" try: unicode(message) except ValueError: assert False, "Message should be valid."
def test_missing_values(self):
message = Message()
with pytest.raises(ValueError):
unicode(message)
message.author = "*****@*****.**"
with pytest.raises(ValueError):
unicode(message)
message.subject = "Attn: Bob Dole"
with pytest.raises(ValueError):
unicode(message)
message.to = "*****@*****.**"
with pytest.raises(ValueError):
unicode(message)
message.plain = "Testing!"
try:
unicode(message)
except ValueError:
assert False, "Message should be valid."
def wsgi(self):
body = self.body
if isinstance(body, binary): body = [body]
elif isinstance(body, unicode): body = [body.encode(self.encoding)]
elif isinstance(body, IO):
def generator(body):
data = body.read(1024)
while data:
yield data
data = body.read(1024)
body = generator(body)
return WSGIData(unicode(self.status).encode('ascii'), [(n, v) for n, v in self.headers.items()], body)
def __eq__(self, other):
if isinstance(other, Address):
return (self.name, self.address) == (other.name, other.address)
elif isinstance(other, unicode):
return unicode(self) == other
elif isinstance(other, bytes):
return bytes(self) == other
elif isinstance(other, tuple):
return (self.name, self.address) == other
raise NotImplementedError(
"Can not compare Address instance against {0} instance".format(
type(other)))
def test_message_recipients_and_addresses(self):
message = self.build_message()
message.cc = '*****@*****.**'
message.bcc = '*****@*****.**'
message.sender = '*****@*****.**'
message.reply = '*****@*****.**'
message.notify = '*****@*****.**'
msg = email.message_from_string(unicode(message))
assert msg['cc'] == '*****@*****.**'
assert msg['bcc'] == None
assert msg['sender'] == '*****@*****.**'
assert msg['reply-to'] == '*****@*****.**'
assert msg['disposition-notification-to'] == '*****@*****.**'
def test_message_recipients_and_addresses(self): message = self.build_message() message.cc = '*****@*****.**' message.bcc = '*****@*****.**' message.sender = '*****@*****.**' message.reply = '*****@*****.**' message.notify = '*****@*****.**' msg = email.message_from_string(unicode(message)) assert msg['cc'] == '*****@*****.**' assert msg['bcc'] == None assert msg['sender'] == '*****@*****.**' assert msg['reply-to'] == '*****@*****.**' assert msg['disposition-notification-to'] == '*****@*****.**'
def __init__(self, name_or_email, email=None, encoding='utf-8'):
self.encoding = encoding
if email is None:
if isinstance(name_or_email, AddressList):
if not 0 < len(name_or_email) < 2:
raise ValueError(
"AddressList to convert must only contain a single Address."
)
name_or_email = unicode(name_or_email[0])
if isinstance(name_or_email, (tuple, list)):
self.name = unicodestr(name_or_email[0], encoding)
self.address = unicodestr(name_or_email[1], encoding)
elif isinstance(name_or_email, bytes):
self.name, self.address = parseaddr(
unicodestr(name_or_email, encoding))
elif isinstance(name_or_email, unicode):
self.name, self.address = parseaddr(name_or_email)
else:
raise TypeError(
'Expected string, tuple or list, got {0} instead'.format(
repr(type(name_or_email))))
else:
self.name = unicodestr(name_or_email, encoding)
self.address = unicodestr(email, encoding)
email, err = EmailValidator().validate_email(self.address)
if err:
raise ValueError('"{0}" is not a valid e-mail address: {1}'.format(
email, err))
def test_message_properties(self):
message = self.build_message()
assert message.author == [("Author", "*****@*****.**")]
assert unicode(message.author) == "Author <*****@*****.**>"
assert isinstance(message.mime, MIMEText)
def test_assign_single_address(self): address = '*****@*****.**' self.addresses = address assert [address] == self.addresses assert unicode(self.addresses) == address
def test_message_properties(self):
message = self.build_message()
assert message.author == [("Author", "*****@*****.**")]
assert unicode(message.author) == "Author <*****@*****.**>"
assert isinstance(message.mime, MIMEText)
def test_initialization_with_string(self):
emailaddress = '*****@*****.**'
address = Address(emailaddress)
eq_(emailaddress, unicode(address))
def __eq__(self, other):
if isinstance(other, (binary, unicode)):
return unicode(self) == unicode(other)
return list(self) == list(other)
def __unicode__(self):
return unicode(self.separator).join(self)
def test_init_accepts_string_list(self): addresses = '[email protected], [email protected]' self.addresses = addresses assert addresses == unicode(self.addresses)
def __repr__(self):
return 'Address("{0}")'.format(unicode(self).encode('ascii', 'backslashreplace'))
def __len__(self):
return len(unicode(self))
def __repr__(self):
return 'Address("{0}")'.format(
unicode(self).encode('ascii', 'backslashreplace'))
def test_path_path(self):
self.assertEquals(Path(Path('/foo')), [unicode(''), unicode('foo')])
def __unicode__(self):
return ", ".join(unicode(i) for i in self)
def test_initialization_with_named_string(self): emailaddress = 'My Name <*****@*****.**>' address = Address(emailaddress) assert unicode(address) == emailaddress
def __eq__(self, other):
if isinstance(other, (binary, unicode)):
return unicode(self) == unicode(other)
return list(self) == list(other)
def __add__(self, other):
return self.__class__(unicode(self) + unicode(other))
def test_address_from_addresslist(self): email = '*****@*****.**' addr = Address(AddressList([Address(email)])) assert unicode(addr) == email
def __add__(self, other):
return self.__class__(unicode(self) + unicode(other))
def test_assign_list_of_addresses(self): addresses = ['*****@*****.**', '*****@*****.**'] self.addresses = addresses assert ', '.join(addresses) == unicode(self.addresses) assert addresses == self.addresses
def __unicode__(self):
return unicode(self.separator).join(self)
def __unicode__(self):
return ", ".join(unicode(i) for i in self)
def test_path_comparison(self):
self.assertEqual(Path('/foo'), (unicode(''), unicode('foo')))
self.assertEqual(Path('/foo'), [unicode(''), unicode('foo')])
self.assertEqual(Path('/foo'), unicode('/foo'))
def test_initialization_with_tuple(self): name = 'Foo' emailaddress = '*****@*****.**' address = Address((name, emailaddress)) assert '%s <%s>' % (name, emailaddress) == unicode(address)
