def test___str__fromString_RepeatedMultipleHeadersWithDifferingContinuationSizes(
self):
"Identity check for fromString, __str__ roundtrip for header with repeated multiple headers with continuations"
value1a = "Twinkle \r\n Twinkle"
value2a = "Little\r\n Star"
value3a = "How I \r\n wonder what you are"
value1b = "Twinkle \r\n Twinkle\r\n Twinkle"
value2b = "Little\r\n Star\r\n Star"
value3b = "How I \r\n wonder what you are\r\n Star"
value1c = "Twinkle \r\n Twinkle\r\n Star"
value2c = "Little\r\n Star\r\n Star"
value3c = "How I \r\n wonder what you are\r\n Star\r\n are!"
header = "Header: " + value1a + "\r\n"
header += "Hooder: " + value2a + "\r\n"
header += "Hooder: " + value3a + "\r\n"
header += "Heeder: " + value3b + "\r\n"
header += "Header: " + value3c + "\r\n"
header += "Heeder: " + value2b + "\r\n"
header += "Heeder: " + value1b + "\r\n"
header += "Hooder: " + value1c + "\r\n"
header += "Header: " + value2c + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assertEqual(str(x), str(y))
self.assertEqual(str(y), message)
def test___str__fromString_RepeatedMultipleHeadersWithDifferingContinuationSizes(self):
"Identity check for fromString, __str__ roundtrip for header with repeated multiple headers with continuations"
value1a = "Twinkle \r\n Twinkle"
value2a = "Little\r\n Star"
value3a = "How I \r\n wonder what you are"
value1b = "Twinkle \r\n Twinkle\r\n Twinkle"
value2b = "Little\r\n Star\r\n Star"
value3b = "How I \r\n wonder what you are\r\n Star"
value1c = "Twinkle \r\n Twinkle\r\n Star"
value2c = "Little\r\n Star\r\n Star"
value3c = "How I \r\n wonder what you are\r\n Star\r\n are!"
header = "Header: " + value1a + "\r\n"
header += "Hooder: " + value2a + "\r\n"
header += "Hooder: " + value3a + "\r\n"
header += "Heeder: " + value3b + "\r\n"
header += "Header: " + value3c + "\r\n"
header += "Heeder: " + value2b + "\r\n"
header += "Heeder: " + value1b + "\r\n"
header += "Hooder: " + value1c + "\r\n"
header += "Header: " + value2c + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assertEqual(str(x), str(y))
self.assertEqual(str(y), message)
def test___str__fromString_RepeatedSingleHeaderWithContinuations(self):
"Identity check for fromString, __str__ roundtrip for header with repeated headers with continuations"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
header = "Header: " + value1 + "\r\n"
header += "Header: " + value2 + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assertEqual(str(x), str(y))
self.assertEqual(str(x), message)
def test___str__fromString_RepeatedSingleHeaderWithContinuations(self):
"Identity check for fromString, __str__ roundtrip for header with repeated headers with continuations"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
header = "Header: " + value1 + "\r\n"
header += "Header: " + value2 + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assertEqual(str(x), str(y))
self.assertEqual(str(x), message)
def test___str__fromString_MultipleHeadersWithContinuations(self):
"Identity check for fromString, __str__ roundtrip for header with multiple headers with continuations"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
value3 = "How I \r\n wonder what you are"
header = "Header: " + value1 + "\r\n"
header += "Heeder: " + value2 + "\r\n"
header += "Hooder: " + value3 + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assertEqual(str(x), str(y))
self.assertEqual(str(y), message)
def test___str__fromString_MultipleHeadersWithContinuations(self):
"Identity check for fromString, __str__ roundtrip for header with multiple headers with continuations"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
value3 = "How I \r\n wonder what you are"
header = "Header: " + value1 + "\r\n"
header += "Heeder: " + value2 + "\r\n"
header += "Hooder: " + value3 + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assertEqual(str(x), str(y))
self.assertEqual(str(y), message)
def test_fromString_RepeatedHeaders_SameOrder(self):
"fromString - Repeated headers after each other retain order in dictionary values"
headerset1 = """HeaderA: value 1\r\nHeaderA: value 2\r\nHeaderA: value 3\r\n"""
headerset2 = """HeaderB: value 4\r\nHeaderB: value 5\r\nHeaderB: value 6\r\n"""
x = MimeDict.fromString(headerset1 + headerset2 + "\r\n")
self.assertEqual(x["HeaderA"], ["value 1", "value 2", "value 3"])
self.assertEqual(x["HeaderB"], ["value 4", "value 5", "value 6"])
def test_fromString_HeaderWithContinuationLines_AllCaptured_One(self):
"fromString - A header with a continuation line is captured as a single string"
value = "Twinkle Twinkle Little Start\r\n How I wonder what you are"
header = "Header: " + value + "\r\n"
body = ""
x = MimeDict.fromString(header + "\r\n" + body)
self.assertEqual(x["Header"], value)
def test_fromString_HeaderMustBeFollowedByEmptyLine_NonEmptyBody(self):
"""fromString - Header not followed by an empty line and non-empty body results is invalid. The result is an empty header and the original message"""
header = "Header: Twinkle Twinkle Little Star\r\n"
body = "How I wonder what you are"
message = header + "" + body # empty "divider"
x = MimeDict.fromString (message)
self.assertEqual(x["__BODY__"], message, "Invalid header results in entire being treated as an unstructured body" )
def test_fromString_HeaderWithContinuationLines_AllCaptured_One(self):
"fromString - A header with a continuation line is captured as a single string"
value = "Twinkle Twinkle Little Start\r\n How I wonder what you are"
header = "Header: " + value + "\r\n"
body = ""
x = MimeDict.fromString(header + "\r\n" + body)
self.assertEqual(x["Header"], value)
def test___str__fromString_BasicRepeatedNonEmptyHeader_EmptyBodyDifferentContinuations(
self):
"Identity check for fromString, __str__ roundtrip for header with multiple different continuations"
x = "Hooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\nHooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\n\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test_Roundtrip_InvalidSourceMessageNonEmptyBody(self):
"Roundtrip handling (fromString->__str__) for invalid messages with an non-empty body should NOT result in equality"
header = "Header: Twinkle Twinkle Little Star\r\n"
body = "How I wonder what you are"
message = header + "" + body # empty "divider"
x = MimeDict.fromString(message)
self.assertEqual(str(x), message)
def test_Roundtrip_InvalidSourceMessageNonEmptyBody(self):
"Roundtrip handling (fromString->__str__) for invalid messages with an non-empty body should NOT result in equality"
header = "Header: Twinkle Twinkle Little Star\r\n"
body = "How I wonder what you are"
message = header + "" + body # empty "divider"
x = MimeDict.fromString(message)
self.assertEqual(str(x), message)
def test_fromString_RepeatedHeaders_SameOrder(self):
"fromString - Repeated headers after each other retain order in dictionary values"
headerset1 = """HeaderA: value 1\r\nHeaderA: value 2\r\nHeaderA: value 3\r\n"""
headerset2 = """HeaderB: value 4\r\nHeaderB: value 5\r\nHeaderB: value 6\r\n"""
x = MimeDict.fromString(headerset1 + headerset2 + "\r\n")
self.assertEqual(x["HeaderA"], ["value 1", "value 2", "value 3"])
self.assertEqual(x["HeaderB"], ["value 4", "value 5", "value 6"])
def test_fromString_HeaderWithContinuationLines_AllCaptured_ManyContinuations(self):
"fromString - A header with many continuation lines is captured as a single string"
value = "Twinkle\r\n Twi nkle\r\n Li ttle Start\r\n How I wonder what y\r\n u are\r\n No Really"
header = "Header: " + value + "\r\n"
body = ""
x = MimeDict.fromString(header + "\r\n" + body)
self.assertEqual(x["Header"], value)
def test___str__fromString_BasicNonEmptyHeader_EmptyBody_OrderPreservation(
self):
"Identity check for fromString, __str__ roundtrip for multiple basic single header, empty body, requires order preservation"
x = "Hooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\n\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_ManyDifferentHeaders_NoBody(self):
"performing __str__/fromString halftrip on a dict with just multiple different simple headers, no body should result in identity"
x = MimeDict(Header="Hello World",
Heeder="Goodbye Smalltown",
Hooder="Bingle")
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test_EmbeddedNewlineInHeaderRoundtrip_fromInsertion(self):
"A header which contains a single carriage return keeps the carriage return embedded since it *isn't* a carriage return/line feed"
x = MimeDict()
x["header"] = "Hello\nWorld"
y = MimeDict.fromString(str(x))
self.assertEqual(y["__BODY__"], "")
self.assertEqual(y["header"], x["header"])
self.assertEqual(x["header"], "Hello\nWorld")
def test_fromString_HeaderMustBeFollowedByEmptyLine(self):
"""fromString - Header not followed by an empty line and empty body
results is invalid. The result is an empty header and the header as the
body."""
header = "Header: Twinkle Twinkle Little Star\r\n"
body = ""
x = MimeDict.fromString (header + "" + body) # empty "divider"
self.assertEqual(x["__BODY__"], header, "Invalid header results in header being treated as an unstructured body" )
def test_fromString_HeaderWithContinuationLines_AllCaptured_ManyContinuations(
self):
"fromString - A header with many continuation lines is captured as a single string"
value = "Twinkle\r\n Twi nkle\r\n Li ttle Start\r\n How I wonder what y\r\n u are\r\n No Really"
header = "Header: " + value + "\r\n"
body = ""
x = MimeDict.fromString(header + "\r\n" + body)
self.assertEqual(x["Header"], value)
def test_basicInsertion_Roundtrip(self):
"Insertion into a dictionary, then roundtripped -- fromString(str(x)) results in original value"
x = MimeDict()
x["hello"] = ["2hello1", "2hello2"]
x["__BODY__"] = "Hello\nWorld\n"
stringified = str(x)
y = MimeDict.fromString(stringified)
self.assertEqual(x, y)
def test_EmbeddedNewlineInHeaderRoundtrip_fromInsertion(self):
"A header which contains a single carriage return keeps the carriage return embedded since it *isn't* a carriage return/line feed"
x = MimeDict()
x["header"] = "Hello\nWorld"
y = MimeDict.fromString(str(x))
self.assertEqual(y["__BODY__"], "")
self.assertEqual(y["header"], x["header"])
self.assertEqual(x["header"], "Hello\nWorld")
def test_basicInsertion_Roundtrip(self):
"Insertion into a dictionary, then roundtripped -- fromString(str(x)) results in original value"
x = MimeDict()
x["hello"] = ["2hello1", "2hello2"]
x["__BODY__"] = "Hello\nWorld\n"
stringified = str(x)
y = MimeDict.fromString(stringified)
self.assertEqual(x, y)
def test_InformationLossRoundtrip(self):
"If you put a list with a single string into a MimeDict, and try to send that across the network by itself, it will not be reconstituted as a list. This is because we have no real way of determining that the single value should or should not be a list"
x = MimeDict()
x["hello"] = ["hello"]
x["__BODY__"] = "Hello\nWorld\n"
stringified = str(x)
y = MimeDict.fromString(stringified)
self.assertNotEqual(x, y)
def test_InformationLossRoundtrip(self):
"If you put a list with a single string into a MimeDict, and try to send that across the network by itself, it will not be reconstituted as a list. This is because we have no real way of determining that the single value should or should not be a list"
x = MimeDict()
x["hello"] = ["hello"]
x["__BODY__"] = "Hello\nWorld\n"
stringified = str(x)
y = MimeDict.fromString(stringified)
self.assertNotEqual(x, y)
def test___str__fromString_MultipleDifferentHeaders_NoBody(self):
"performing __str__/fromString halftrip on a dict with multiple header types multiple times, no body should result in identity"
x = MimeDict(HeaderA=["value 1", "value 2", "value 3"], HeaderB=["value 4", "value 5", "value 6"])
y = MimeDict.fromString(str(x))
self.assertEqual(y, x)
self.assertEqual(y["HeaderA"], ["value 1", "value 2", "value 3"])
self.assertEqual(y["HeaderB"], ["value 4", "value 5", "value 6"])
self.assert_(x is not y)
def test___str__CheckedAgainstOriginalRepeatedSingleHeaderWithContinuations(self):
"__str__ of fromString(message) checked against message for equality"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
header = "Header: " + value1 + "\r\n"
header += "Header: " + value2 + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
self.assertEqual(str(x), message)
def test___str__fromString_MultipleDifferentHeaders_NoBody(self):
"performing __str__/fromString halftrip on a dict with multiple header types multiple times, no body should result in identity"
x = MimeDict(HeaderA=["value 1", "value 2", "value 3"],
HeaderB=["value 4", "value 5", "value 6"])
y = MimeDict.fromString(str(x))
self.assertEqual(y, x)
self.assertEqual(y["HeaderA"], ["value 1", "value 2", "value 3"])
self.assertEqual(y["HeaderB"], ["value 4", "value 5", "value 6"])
self.assert_(x is not y)
def test_fromString_HeaderMustBeFollowedByEmptyLine_NonEmptyBody(self):
"""fromString - Header not followed by an empty line and non-empty body results is invalid. The result is an empty header and the original message"""
header = "Header: Twinkle Twinkle Little Star\r\n"
body = "How I wonder what you are"
message = header + "" + body # empty "divider"
x = MimeDict.fromString(message)
self.assertEqual(
x["__BODY__"], message,
"Invalid header results in entire being treated as an unstructured body"
)
def test_fromString_HeaderMustBeFollowedByEmptyLine(self):
"""fromString - Header not followed by an empty line and empty body
results is invalid. The result is an empty header and the header as the
body."""
header = "Header: Twinkle Twinkle Little Star\r\n"
body = ""
x = MimeDict.fromString(header + "" + body) # empty "divider"
self.assertEqual(
x["__BODY__"], header,
"Invalid header results in header being treated as an unstructured body"
)
def test_fromString_RepeatedInterleaved_Headers_SameOrder(self):
"fromString - Repeated interleaved headers after each other retain order in dictionary values"
headers = "HeaderA: value 1\r\n"
headers += "HeaderB: value 4\r\n"
headers += "HeaderA: value 2\r\n"
headers += "HeaderB: value 5\r\n"
headers += "HeaderA: value 3\r\n"
headers += "HeaderB: value 6\r\n"
x = MimeDict.fromString(headers + "\r\n")
self.assertEqual(x["HeaderA"], ["value 1", "value 2", "value 3"])
self.assertEqual(x["HeaderB"], ["value 4", "value 5", "value 6"])
def test___str__CheckedAgainstOriginalRepeatedSingleHeaderWithContinuations(
self):
"__str__ of fromString(message) checked against message for equality"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
header = "Header: " + value1 + "\r\n"
header += "Header: " + value2 + "\r\n"
body = ""
message = header + "\r\n" + body
x = MimeDict.fromString(message)
self.assertEqual(str(x), message)
def test_fromString_ManyHeaderLineNonEmptyBody(self):
"fromString - Many header lines followed by an empty line and a body is valid"
header = "Header: line\r\nHeeder: line\r\nHooder: line\r\n"
body = "This is a random body\r\nWibbleWibble\r\n"
x = MimeDict.fromString(header + "\r\n" + body)
self.assertEqual(
x,
MimeDict(Header="line",
Heeder="line",
Hooder="line",
__BODY__=body))
def test_fromString_RepeatedInterleaved_Headers_SameOrder(self):
"fromString - Repeated interleaved headers after each other retain order in dictionary values"
headers = "HeaderA: value 1\r\n"
headers += "HeaderB: value 4\r\n"
headers += "HeaderA: value 2\r\n"
headers += "HeaderB: value 5\r\n"
headers += "HeaderA: value 3\r\n"
headers += "HeaderB: value 6\r\n"
x = MimeDict.fromString(headers + "\r\n")
self.assertEqual(x["HeaderA"], ["value 1", "value 2", "value 3"])
self.assertEqual(x["HeaderB"], ["value 4", "value 5", "value 6"])
def test_fromString_HeaderWithContinuationLines_AllCaptured_ManyHeaders(self):
"fromString - Multiple headers with continuation lines captured as a string for each header"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
value3 = "How I \r\n wonder what you are"
header1 = "Header: " + value1 + "\r\n"
header2 = "Heeder: " + value2 + "\r\n"
header3 = "Hooder: " + value3 + "\r\n"
body = ""
message = header1 + header2 + header3 + "\r\n" + body
x = MimeDict.fromString(message)
self.assertEqual(x["Header"], value1)
self.assertEqual(x["Heeder"], value2)
self.assertEqual(x["Hooder"], value3)
def test_fromString_HeaderWithContinuationLines_AllCaptured_ManyHeaders(
self):
"fromString - Multiple headers with continuation lines captured as a string for each header"
value1 = "Twinkle \r\n Twinkle"
value2 = "Little\r\n Star"
value3 = "How I \r\n wonder what you are"
header1 = "Header: " + value1 + "\r\n"
header2 = "Heeder: " + value2 + "\r\n"
header3 = "Hooder: " + value3 + "\r\n"
body = ""
message = header1 + header2 + header3 + "\r\n" + body
x = MimeDict.fromString(message)
self.assertEqual(x["Header"], value1)
self.assertEqual(x["Heeder"], value2)
self.assertEqual(x["Hooder"], value3)
def test___str__fromString_BasicNonEmptyHeader_EmptyBody(self):
"Identity check for fromString, __str__ roundtrip for single basic single header, empty body"
x = "Header: Hello\r\n\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test_EmptyFieldRoundTrip(self):
"Empty header remains empty"
x = MimeDict()
x["header"] = ""
y = MimeDict.fromString(str(x))
self.assertEqual(x["header"], y["header"])
def test_fromString_RepeatedHeaderResultsInListInOriginalOrder(self):
"fromString - Repeated header with same key results in list with values in original order'"
header = """Header: value 1\r\nHeader: value 2\r\nHeader: value 3\r\n"""
x = MimeDict.fromString(header + "\r\n")
self.assertEqual(x["Header"], ["value 1", "value 2", "value 3"])
def test___str__fromString_OnlyBody(self):
"performing __str__ on a dict with just a __BODY__ and then fromString should result in the same dict"
x = MimeDict(__BODY__="Hello World")
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_ManySameHeaders_NoBody(self):
"performing __str__/fromString halftrip on a dict with single header type multiple times, no body should result in identity"
x = MimeDict(Header=["Hello World", "Goodbye Smalltown", "Bingle"])
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_emptyHeaderNonEmptyBody(self):
"Identity check for fromString, __str__ roundtrip for the empty header, non empty body"
x = "\r\nHello World"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_OnlyBody(self):
"performing __str__ on a dict with just a __BODY__ and then fromString should result in the same dict"
x = MimeDict(__BODY__="Hello World")
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_emptyDict(self):
"performing __str__ on an empty dict and then fromString should result in empty dict"
x = MimeDict()
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test_EmptyFieldRoundTrip(self):
"Empty header remains empty"
x = MimeDict()
x["header"] = ""
y = MimeDict.fromString(str(x))
self.assertEqual(x["header"], y["header"])
def test_fromString_RepeatedHeaderResultsInListInOriginalOrder(self):
"fromString - Repeated header with same key results in list with values in original order'"
header = """Header: value 1\r\nHeader: value 2\r\nHeader: value 3\r\n"""
x = MimeDict.fromString(header + "\r\n")
self.assertEqual(x["Header"], ["value 1", "value 2", "value 3"])
def test_fromString_RepeatedHeaderResultsInList(self):
"fromString - Repeated header with same key results in a list of values associated'"
header = """Header: value 1\r\nHeader: value 2\r\nHeader: value 3\r\n"""
x = MimeDict.fromString(header + "\r\n")
self.assert_(isinstance(x["Header"], list), "Should be a list associated with 'Header'")
def test___str__fromString_BasicRepeatedNonEmptyHeader_EmptyBody(self):
"Identity check for fromString, __str__ roundtrip for multiple repeated basic single header, empty body, requires order preservation"
x = "Hooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\nHooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\n\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_BasicRepeatedNonEmptyHeader_EmptyBodyDifferentContinuations(self):
"Identity check for fromString, __str__ roundtrip for header with multiple different continuations"
x = "Hooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\nHooder: Bingle\r\nHeader: Hello\r\nHeeder: Wind\r\n\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_OneHeader_NoBody(self):
"performing __str__/fromString halftrip on a dict with just one header, no body should result in identity"
x = MimeDict(Header="Hello World")
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_emptyMessage(self):
"Performing a fromString, __str__ roundtrip results in identity forthe empty message"
x = "\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_ManyDifferentHeaders_NoBody(self):
"performing __str__/fromString halftrip on a dict with just multiple different simple headers, no body should result in identity"
x = MimeDict(Header="Hello World", Heeder="Goodbye Smalltown", Hooder="Bingle")
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_OneHeader_NoBody(self):
"performing __str__/fromString halftrip on a dict with just one header, no body should result in identity"
x = MimeDict(Header="Hello World")
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_ManySameHeaders_NoBody(self):
"performing __str__/fromString halftrip on a dict with single header type multiple times, no body should result in identity"
x = MimeDict(Header=["Hello World", "Goodbye Smalltown", "Bingle"])
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_emptyDict(self):
"performing __str__ on an empty dict and then fromString should result in empty dict"
x = MimeDict()
y = MimeDict.fromString(str(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_BasicNonEmptyHeader_EmptyBody(self):
"Identity check for fromString, __str__ roundtrip for single basic single header, empty body"
x = "Header: Hello\r\n\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_emptyMessage(self):
"Performing a fromString, __str__ roundtrip results in identity forthe empty message"
x = "\r\n"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test___str__fromString_emptyHeaderNonEmptyBody(self):
"Identity check for fromString, __str__ roundtrip for the empty header, non empty body"
x = "\r\nHello World"
y = str(MimeDict.fromString(x))
self.assertEqual(x, y)
self.assert_(x is not y)
def test_SingleSpaceFieldRoundTrip(self):
"Header with a single space remains a header with a single space"
x = MimeDict()
x["header"] = " "
y = MimeDict.fromString(str(x))
self.assertEqual(x["header"], y["header"])
def test_SingleSpaceFieldRoundTrip(self):
"Header with a single space remains a header with a single space"
x = MimeDict()
x["header"] = " "
y = MimeDict.fromString(str(x))
self.assertEqual(x["header"], y["header"])