Example #1
0
 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)
Example #2
0
 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)
Example #3
0
 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)
Example #4
0
 def test__str__SampleNonEmptyDict(self):
     "__str__ - Dict with multiple headers each with 1 associated simple string value should result in leading Key: Value lines"
     x = MimeDict(Hello="World", Sheep="Dolly", Marvin="Android", Cat="Garfield")
     lines = str(x).splitlines(True)
     self.assertEqual(lines[4], "\r\n")
     header = lines[:4]
     header.sort()
     keys = x.keys()
     keys.sort()
     h = 0
     for k in keys:
         if k == "__BODY__":
             continue
         self.assertEqual(header[h], "%s: %s\r\n" % (k, x[k]))
         h += 1
Example #5
0
 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)
Example #6
0
 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)
Example #7
0
 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"])
Example #8
0
 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)
Example #9
0
 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" )
Example #10
0
 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" )
Example #11
0
 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)
Example #12
0
 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")
Example #13
0
    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)
Example #14
0
    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)
Example #15
0
 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)
Example #16
0
 def test__str__TwoListsLengthTwoValues(self):
     "__str__ - Dict with 2 keys, each with lists of multiple values, both get inserted, possibly mixed up"
     x = MimeDict(Greeting=["Hello", "Bonjour"],
                  Parting=["Farewell", "Goodbye"])
     lines = str(x).splitlines(True)
     header = lines[:4]
     header.sort()
     self.assertEqual("Greeting: Bonjour\r\n", header[0])
     self.assertEqual("Greeting: Hello\r\n", header[1])
     self.assertEqual("Parting: Farewell\r\n", header[2])
     self.assertEqual("Parting: Goodbye\r\n", header[3])
Example #17
0
 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"])
Example #18
0
 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)
Example #19
0
 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"
     )
Example #20
0
 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"])
Example #21
0
 def test___str__fromString_RepeatedMultipleHeadersWithContinuations(self):
     "Identity check for fromString, __str__ roundtrip for header with repeated 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 += "Hooder: " + value2 + "\r\n"
     header += "Hooder: " + value3 + "\r\n"
     header += "Heeder: " + value3 + "\r\n"
     header += "Header: " + value3 + "\r\n"
     header += "Heeder: " + value2 + "\r\n"
     header += "Heeder: " + value1 + "\r\n"
     header += "Hooder: " + 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(y), message)
Example #22
0
 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)
Example #23
0
 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)
Example #24
0
 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)
Example #25
0
 def test_fromString_HeaderMustBeFollowedByEmptyLine2(self):
     """fromString - Invalid header which was partially successfully parsed results in 'empty' dict - only valid key is __BODY__"""
     header = "Header: Twinkle Twinkle Little Star\r\n"
     body = ""
     x = MimeDict.fromString(header + "" + body)  # empty "divider"
     self.assertEqual(x.keys(), ["__BODY__"])
Example #26
0
 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)
Example #27
0
 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)
Example #28
0
 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)
Example #29
0
 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)
Example #30
0
 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)
Example #31
0
 def test_fromString_ManyHeaderLineEmptyBody(self):
     "fromString - Many header lines followed by an empty line is valid"
     header = "Header: line\r\nHeeder: line\r\nHooder: line\r\n"
     x = MimeDict.fromString(header + "\r\n")
     self.assertEqual(x,
                      MimeDict(Header="line", Heeder="line", Hooder="line"))
Example #32
0
 def test__str__NonEmptyDictEmptyBody(self):
     "__str__ - String representation a non empty dict with no body should finish with an empty line - last 4 chars should be network EOL"
     x = MimeDict(Hello="World", Fate="Success")
     self.assertEqual(str(x)[-4:], "\r\n\r\n")
Example #33
0
 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"])
Example #34
0
 def test_EmptyFieldRoundTrip(self):
     "Empty header remains empty"
     x = MimeDict()
     x["header"] = ""
     y = MimeDict.fromString(str(x))
     self.assertEqual(x["header"], y["header"])
Example #35
0
 def test__str__emptyDict(self):
     "__str__ - The string representation of an empty MimeDict should be precisely 1 empty line"
     x = MimeDict()
     self.assertEqual(str(x), '\r\n')
Example #36
0
 def test_basicInsertion(self):
     "Insertion into a dictionary succeeds"
     x = MimeDict()
     x["hello"] = "hello"
     self.assertEqual("hello", x["hello"])
Example #37
0
 def test__init__New__BODY__NotClobbered(self):
     "__init__ - Passing over a __BODY__ argument should be stored and not clobbered"
     x = MimeDict(__BODY__="Hello World")
     self.assert_("__BODY__" in x)
     self.assertEqual(x["__BODY__"], "Hello World")
Example #38
0
 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)
Example #39
0
 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)
Example #40
0
 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"])
Example #41
0
 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)
Example #42
0
 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'")
Example #43
0
 def test_SmokeTest_SubClassOfDict(self):
     "__init__ - MimeDict items are also dictionaries"
     x = MimeDict()
     self.assert_(isinstance(x, MimeDict))
     self.assert_(isinstance(x, dict))
Example #44
0
 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)
Example #45
0
 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)
Example #46
0
 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)
Example #47
0
 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)
Example #48
0
 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)
Example #49
0
 def test_fromString_HeaderWithContinuationLines_EmptyBody(self):
     "fromString - Header lines may continue over multiple lines, and are considered part of the header, meaning if the body is empty, the __BODY__ should be too"
     header = "Header: Twinkle Twinkle Little Start\r\n   How I wonder what you are\r\n"
     body = ""
     x = MimeDict.fromString(header + "\r\n" + body)
     self.assertEqual(x["__BODY__"], "")
Example #50
0
 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"])
Example #51
0
 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)
Example #52
0
 def test__init__emptyDict_hasBody(self):
     "__init__ - An empty MimeDict always has a __BODY__ attribute"
     x = MimeDict()
     self.assert_("__BODY__" in x)
Example #53
0
 def test_fromString_HeaderLineNonEmptyBody(self):
     "fromString - A header line followed by an empty line and a body is valid"
     header = "Header: 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", __BODY__=body))
Example #54
0
 def test_SmokeTest_NoArguments(self):
     "__init__ - Creating an empty mime dict does not raise any exception"
     x = MimeDict()
Example #55
0
 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)
Example #56
0
 def test_fromString_HeaderWithContinuationLines_NonEmptyBody(self):
     "fromString - Headers with continuations should not be extended by a body that looks like a continuation"
     header = "Header: Twinkle Twinkle Little Start\r\n   How I wonder what you are\r\n"
     body = "   This leading body looks like a continuation"
     x = MimeDict.fromString(header + "\r\n" + body)
     self.assertEqual(x["__BODY__"], body)
Example #57
0
 def test_EmptyFieldRoundTrip(self):
     "Empty header remains empty"
     x = MimeDict()
     x["header"] = ""
     y = MimeDict.fromString(str(x))
     self.assertEqual(x["header"], y["header"])
Example #58
0
 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)
Example #59
0
 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"])
Example #60
0
 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)