#! /usr/bin/env python ############################################################################ # Copyright (C) 2002 Paul Rodger # (C) 2006-2010 Nikolaus Schulz # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ############################################################################ """ Unit-test archivemail using 'PyUnit'. TODO: add tests for: * dotlock locks already existing * archiving MH-format mailboxes * a 3rd party process changing the mbox file being read """ import sys def check_python_version(): """Abort if we are running on python < v2.3""" too_old_error = "This test script requires python version 2.3 or later. " + \ "Your version of python is:\n%s" % sys.version try: version = sys.version_info # we might not even have this function! :) if (version[0] < 2) or (version[0] == 2 and version[1] < 3): print too_old_error sys.exit(1) except AttributeError: print too_old_error sys.exit(1) # define & run this early because 'unittest' requires Python >= 2.1 check_python_version() import copy import fcntl import filecmp import os import re import shutil import stat import tempfile import time import unittest import gzip import cStringIO import rfc822 import mailbox from types import ModuleType archivemail = ModuleType("archivemail") try: module_fp = open("archivemail", "r") except IOError: print "The archivemail script should be in the current directory in order" print "to be imported and tested. Sorry." sys.exit(1) exec module_fp in archivemail.__dict__ # We want to iterate over messages in a compressed archive mbox and verify # them. This involves seeking in the mbox. The gzip.Gzipfile.seek() in # Python 2.5 doesn't understand whence; this is Python bug #1355023, triggered # by mailbox._PartialFile.seek(). The bug is still pending as of Python # 2.5.2. To work around it, we subclass gzip.GzipFile. # # It should be noted that seeking backwards in a GzipFile is emulated by # re-reading the entire file from the beginning, which is extremely # inefficient and won't work with large files; but our test archives are all # small, so it's okay. class FixedGzipFile(gzip.GzipFile): """GzipFile with seek method accepting whence parameter.""" def seek(self, offset, whence=0): try: # Try calling gzip.GzipFile.seek with the whence parameter. # For Python >= 2.7, it returns the new offset; pass that on. return gzip.GzipFile.seek(self, offset, whence) except TypeError: if whence: if whence == 1: offset = self.offset + offset else: raise ValueError('Seek from end not supported') return gzip.GzipFile.seek(self, offset) # precision of os.utime() when restoring mbox timestamps utimes_precision = 5 class MessageIdFactory: """Factory to create `uniqe' message-ids.""" def __init__(self): self.seq = 0 def __call__(self): self.seq += 1 return "" % self.seq make_msgid = MessageIdFactory() class IndexedMailboxDir: """An indexed mailbox directory, providing random message access by message-id. Intended as a base class for a maildir and an mh subclass.""" def __init__(self, mdir_name): assert tempfile.tempdir self.root = tempfile.mkdtemp(prefix=mdir_name) self.msg_id_dict = {} self.deliveries = 0 def _add_to_index(self, msg_text, fpath): """Add the given message to the index, for later random access.""" # Extract the message-id as index key msg_id = None fp = cStringIO.StringIO(msg_text) while True: line = fp.readline() # line empty means we didn't find a message-id assert line if line.lower().startswith("message-id:"): msg_id = line.split(":", 1)[-1].strip() assert msg_id break assert not self.msg_id_dict.has_key(msg_id) self.msg_id_dict[msg_id] = fpath def get_all_filenames(self): """Return all relative pathnames of files in this mailbox.""" return self.msg_id_dict.values() class SimpleMaildir(IndexedMailboxDir): """Primitive Maildir class, just good enough for generating short-lived test maildirs.""" def __init__(self, mdir_name='maildir'): IndexedMailboxDir.__init__(self, mdir_name) for d in "cur", "tmp", "new": os.mkdir(os.path.join(self.root, d)) def write(self, msg_str, new=True, flags=[]): """Store a message with the given flags.""" assert not (new and flags) if new: subdir = "new" else: subdir = "cur" fname = self._mkname(new, flags) relpath = os.path.join(subdir, fname) path = os.path.join(self.root, relpath) assert not os.path.exists(path) f = open(path, "w") f.write(msg_str) f.close() self._add_to_index(msg_str, relpath) def _mkname(self, new, flags): """Generate a unique filename for a new message.""" validflags = 'DFPRST' for f in flags: assert f in validflags # This 'unique' name should be good enough, since nobody else # will ever write messages to this maildir folder. uniq = str(self.deliveries) self.deliveries += 1 if new: return uniq if not flags: return uniq + ':2,' finfo = "".join(sorted(flags)) return uniq + ':2,' + finfo def get_message_and_mbox_status(self, msgid): """For the Message-Id msgid, return the matching message in text format and its status, expressed as a set of mbox flags.""" fpath = self.msg_id_dict[msgid] # Barfs if not found mdir_flags = fpath.rsplit('2,', 1)[-1] flagmap = { 'F': 'F', 'R': 'A', 'S': 'R' } mbox_flags = set([flagmap[x] for x in mdir_flags]) if fpath.startswith("cur/"): mbox_flags.add('O') fp = open(os.path.join(self.root, fpath), "r") msg = fp.read() fp.close() return msg, mbox_flags class TestCaseInTempdir(unittest.TestCase): """Base class for testcases that need to create temporary files. All testcases that create temporary files should be derived from this class, not directly from unittest.TestCase. TestCaseInTempdir provides these methods: setUp() Creates a safe temporary directory and sets tempfile.tempdir. tearDown() Recursively removes the temporary directory and unsets tempfile.tempdir. Overriding methods should call the ones above.""" temproot = None def setUp(self): if not self.temproot: assert not tempfile.tempdir self.temproot = tempfile.tempdir = \ tempfile.mkdtemp(prefix="test-archivemail") 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
  <head>
    <meta name="generator" content=
    "HTML Tidy for Linux/x86 (vers 1st April 2002), see www.w3.org">

    <title>Requisites for working multidrop mailboxes</title>
    <meta name="author" content="Matthias Andree">
    <meta http-equiv="Content-Type" content=
    "text/html;charset=utf-8">
    <link rev="made" href="mailto:matthias.andree@gmx.de">
    <style type="text/css">
            <!--
            body {
                background-color: #ffffff;
                color: #000000;
            }
            //-->
                    </style>
  </head>

  <body>
    <a href="multidrop.de.html">Link zur deutschen Version/link to German-language version</a>

    <h1>Requisites for working multidrop mailboxes</h1>

    <address>
      <a href="mailto:matthias.andree@gmx.de">Matthias Andree</a> 2004-05-27
    </address>

    <h2>Introduction</h2>

    <p>Many ISPs offer a POP3 multidrop or "domain in a mailbox"
    setup to their clients who can then fetch mail for multiple
    recipients in their domain "in one go".</p>

    <p>Often enough, such an undertaking goes awry during the mail
    fetch, causes and remedies are to be presented in this
    document.</p>

    <h2>Initial Examination</h2>

    <p>POP3, the Post Office Protocol version 3, was intended to
    transport mail for a single recipient. It does not keep the
    envelope that indicates the actual recipient and sender.</p>

    <p>The envelope sender is often copied to the "Return-Path"
    header, with respect to the envelope recipient, every
    programmer of a mail server will have their own implementation.
    Common solutions are "do nothing" (sendmail), "Delivered-To:"
    (in qmail, potentially with a domain prefix; Postfix),
    "X-Envelope-To:" (certain procmail-based setups) and
    "X-Original-To:" (Postfix releases after 2002-10-25 will write
    this in addition to Envelope-To:)</p>

    <p><strong>Important background information:</strong> Mail
    headers such as To:, Cc:, Bcc: are IRRELEVANT for routing and
    delivery of the mail. Mail routing will only look at the
    ENVELOPE - there is no difference from snail mail here.</p>

    <p>We will frequently see that upon injection, the envelope is
    created from the headers, but ONLY THE ENVELOPE carries, in
    contrast to the HEADER, the full information:</p>

    <ul>
      <li>Bcc: is removed from the header - it is supposed to be
      invisible to the recipients</li>

      <li>To: and Cc: are not updated to reflect the new target
      when mail is being redirected</li>

      <li>To: and Cc:, in mailing list mail, contain the LIST
      address and not the subscriber's address</li>
    </ul>

    <p>Dropping off mail for multiple distinct recipients in the
    same mailbox requires the server to deposit the actual
    recipient in the mail in order to achieve proper delivery. POP3
    makes no provisions, so this must take place outside the
    protocol, the mail header lends itself to the task.</p>

    <h2>Requirements</h2>

    <p>POP3 multidrop can work reliably all the same, provided that
    some requirements are met. These are:</p>

    <ol>
      <li>The ISP MUST drop one copy per recipient in that
      domain.</li>

      <li>The ISP MUST deposit the envelope recipient in the mail
      header. Which one your ISP chooses can be asked from their
      tech support or you'll see it when looking at a mail header.
      You'll typically find X-Original-To:, X-Envelope-To:,
      Delivered-To:.</li>

      <li>The POP3 client (Mercury/32, fetchmail, getmail, ...)
      MUST reliably recognise the header where the envelope
      recipient has been deposited and use ONLY this header for
      mail delivery.</li>

      <li><strong>The POP3 client MUST IN NO CASE evaluate To: or
      Cc: headers. It MUST ON NO ACCOUNT feed the mail into a
      command that is used for injection, such as
      sendmail&nbsp;-t&nbsp;-oi (whereas sendmail with a fixed
      local mail address, for instance, sendmail&nbsp;-oi&nbsp;joe,
      is justifiable).</strong></li>
    </ol>

    <h2>Explanations</h2>

    <dl>
      <dt>Ad 1:</dt>

      <dd>If this requirement is not met, mails to multiple
      recipients of the multidrop domain will only reach one of the
      recipients.</dd>

      <dt>Ad 2:</dt>

      <dd>
        If this requirement is not met, delivery will be faulty.
        Attempting to derive this information from the headers
        (To:, Cc:) is dangerous and unreliable: 

        <ul>
          <li>Mail for mailing lists (which have their addresses in
          the To: or Cc: header) will loop, which must be
          avoided</li>

          <li>the regeneration of recipients that were placed in
          the Bcc: header at the sender's site, is impossible
          because the Bcc: header is removed for transport, as the
          name "blind carbon copy" suggests.</li>
        </ul>
      </dd>
    </dl>
    <!-- vim: set filetype=html: -->
  </body>
</html>
generated by cgit v1.2.3 (git 2.46.0) at 2026-06-14 14:21:49 +0000
d = True else: assert not os.path.exists(archive_name + ".gz") iszipped = False if self.good_archive is not None: assertEqualContent(archive_name, self.good_archive, iszipped) else: assert not os.path.exists(archive_name) def make_old_mbox(self, body=None, headers=None, messages=1, make_old_archive=False): """Prepare for a test run with an old mbox by making an old mbox, optionally an existing archive, and a reference archive to verify the archive after archivemail has run.""" self.mbox = make_mbox(body, headers, 181*24, messages) archive_does_change = not (archivemail.options.dry_run or archivemail.options.delete_old_mail) mbox_does_not_change = archivemail.options.dry_run or \ archivemail.options.copy_old_mail if make_old_archive: archive = archivemail.make_archive_name(self.mbox) self.good_archive = make_archive_and_plain_copy(archive) if archive_does_change: append_file(self.mbox, self.good_archive) elif archive_does_change: self.good_archive = tempfile.mkstemp()[1] shutil.copyfile(self.mbox, self.good_archive) if mbox_does_not_change: if archive_does_change and not make_old_archive: self.good_mbox = self.good_archive else: self.good_mbox = tempfile.mkstemp()[1] shutil.copyfile(self.mbox, self.good_mbox) def make_mixed_mbox(self, body=None, headers=None, messages=1, make_old_archive=False): """Prepare for a test run with a mixed mbox by making a mixed mbox, optionally an existing archive, a reference archive to verify the archive after archivemail has run, and likewise a reference mbox to verify the mbox.""" self.make_old_mbox(body, headers, messages=messages, make_old_archive=make_old_archive) new_mbox_name = make_mbox(body, headers, 179*24, messages) append_file(new_mbox_name, self.mbox) if self.good_mbox is None: self.good_mbox = new_mbox_name else: if self.good_mbox == self.good_archive: self.good_mbox = tempfile.mkstemp()[1] shutil.copyfile(self.mbox, self.good_mbox) else: append_file(new_mbox_name, self.good_mbox) def make_new_mbox(self, body=None, headers=None, messages=1, make_old_archive=False): """Prepare for a test run with a new mbox by making a new mbox, optionally an exiting archive, and a reference mbox to verify the mbox after archivemail has run.""" self.mbox = make_mbox(body, headers, 179*24, messages) self.good_mbox = tempfile.mkstemp()[1] shutil.copyfile(self.mbox, self.good_mbox) if make_old_archive: archive = archivemail.make_archive_name(self.mbox) self.good_archive = make_archive_and_plain_copy(archive) class TestArchiveMbox(TestArchive): """archiving should work based on the date of messages given""" def setUp(self): self.oldopts = copy.copy(archivemail.options) archivemail.options.quiet = True super(TestArchiveMbox, self).setUp() def testOld(self): """archiving an old mailbox""" self.make_old_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testOldFromInBody(self): """archiving an old mailbox with 'From ' in the body""" body = """This is a message with ^From at the start of a line From is on this line This is after the ^From line""" self.make_old_mbox(messages=3, body=body) archivemail.archive(self.mbox) self.verify() def testDateSystem(self): """test that the --date option works as expected""" test_headers = ( { 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, { 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2000', 'Date' : None, }, { 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : None, 'Delivery-date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, { 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : None, 'Resent-Date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, ) for headers in test_headers: msg = make_message(default_headers=headers, wantobj=True) date = time.strptime("2000-07-29", "%Y-%m-%d") archivemail.options.date_old_max = time.mktime(date) assert archivemail.should_archive(msg) date = time.strptime("2000-07-27", "%Y-%m-%d") archivemail.options.date_old_max = time.mktime(date) assert not archivemail.should_archive(msg) def testMixed(self): """archiving a mixed mailbox""" self.make_mixed_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testNew(self): """archiving a new mailbox""" self.make_new_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testOldExisting(self): """archiving an old mailbox with an existing archive""" self.make_old_mbox(messages=3, make_old_archive=True) archivemail.archive(self.mbox) self.verify() def testOldWeirdHeaders(self): """archiving old mailboxes with weird headers""" weird_headers = ( { # we should archive because of the date on the 'From_' line 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2000', 'Date' : 'Friskhdfkjkh, 28 Jul 2002 1line noise6:11:36 +1000', }, { # we should archive because of the date on the 'From_' line 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2000', 'Date' : None, }, { # we should archive because of the date in 'Delivery-date' 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : 'Frcorruptioni, 28 Jul 20line noise00 16:6 +1000', 'Delivery-date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, { # we should archive because of the date in 'Delivery-date' 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : None, 'Delivery-date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, { # we should archive because of the date in 'Resent-Date' 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : 'Frcorruptioni, 28 Jul 20line noise00 16:6 +1000', 'Resent-Date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, { # we should archive because of the date in 'Resent-Date' 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2030', 'Date' : None, 'Resent-Date' : 'Fri, 28 Jul 2000 16:11:36 +1000', }, { # completely blank dates were crashing < version 0.4.7 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2000', 'Date' : '', }, { # completely blank dates were crashing < version 0.4.7 'From_' : 'sender@dummy.domain Fri Jul 28 16:11:36 2000', 'Date' : '', 'Resent-Date' : '', }, ) fd, self.mbox = tempfile.mkstemp() fp = os.fdopen(fd, "w") for headers in weird_headers: msg_text = make_message(default_headers=headers) fp.write(msg_text*2) fp.close() self.good_archive = tempfile.mkstemp()[1] shutil.copyfile(self.mbox, self.good_archive) archivemail.archive(self.mbox) self.verify() def tearDown(self): archivemail.options = self.oldopts super(TestArchiveMbox, self).tearDown() class TestArchiveMboxTimestamp(TestCaseInTempdir): """original mbox timestamps should always be preserved""" def setUp(self): super(TestArchiveMboxTimestamp, self).setUp() archivemail.options.quiet = True self.mbox_name = make_mbox(messages=3, hours_old=(24 * 180)) self.mtime = os.path.getmtime(self.mbox_name) - 66 self.atime = os.path.getatime(self.mbox_name) - 88 os.utime(self.mbox_name, (self.atime, self.mtime)) def testNew(self): """mbox timestamps should not change after no archival""" archivemail.options.days_old_max = 181 archivemail.archive(self.mbox_name) self.verify() def testOld(self): """mbox timestamps should not change after archival""" archivemail.options.days_old_max = 179 archivemail.archive(self.mbox_name) self.verify() def verify(self): assert os.path.exists(self.mbox_name) new_atime = os.path.getatime(self.mbox_name) new_mtime = os.path.getmtime(self.mbox_name) self.assertAlmostEqual(self.mtime, new_mtime, utimes_precision) self.assertAlmostEqual(self.atime, new_atime, utimes_precision) def tearDown(self): archivemail.options.quiet = False archivemail.options.days_old_max = 180 os.remove(self.mbox_name) super(TestArchiveMboxTimestamp, self).tearDown() class TestArchiveMboxAll(unittest.TestCase): def setUp(self): archivemail.options.quiet = True archivemail.options.archive_all = True def testNew(self): """new messages should be archived with --all""" self.msg = make_message(hours_old=24*179, wantobj=True) assert archivemail.should_archive(self.msg) def testOld(self): """old messages should be archived with --all""" self.msg = make_message(hours_old=24*181, wantobj=True) assert archivemail.should_archive(self.msg) def tearDown(self): archivemail.options.quiet = False archivemail.options.archive_all = False class TestArchiveMboxPreserveUnread(unittest.TestCase): """make sure the 'preserve_unread' option works""" def setUp(self): archivemail.options.quiet = True archivemail.options.preserve_unread = True self.msg = make_message(hours_old=24*181, wantobj=True) def testOldRead(self): """old read messages should be archived with --preserve-unread""" self.msg["Status"] = "RO" assert archivemail.should_archive(self.msg) def testOldUnread(self): """old unread messages should not be archived with --preserve-unread""" self.msg["Status"] = "O" assert not archivemail.should_archive(self.msg) def tearDown(self): archivemail.options.quiet = False archivemail.options.preserve_unread = False class TestArchiveMboxSuffix(unittest.TestCase): """make sure the 'suffix' option works""" def setUp(self): archivemail.options.quiet = True def testSuffix(self): """archiving with specified --suffix arguments""" for suffix in ("_static_", "_%B_%Y", "-%Y-%m-%d"): mbox_name = "foobar" archivemail.options.archive_suffix = suffix days_old_max = 180 parsed_suffix_time = time.time() - days_old_max*24*60*60 parsed_suffix = time.strftime(suffix, time.localtime(parsed_suffix_time)) archive_name = mbox_name + parsed_suffix self.assertEqual(archive_name, archivemail.make_archive_name(mbox_name)) def tearDown(self): archivemail.options.quiet = False archivemail.options.archive_suffix = None class TestArchiveMboxPrefix(unittest.TestCase): """make sure the 'prefix' option works""" def setUp(self): archivemail.options.quiet = True def testPrefix(self): """archiving with specified --prefix arguments""" for archive_prefix in ("_static_", "_%B_%Y", "-%Y-%m-%d", "%Y/%m/"): archivemail.options.archive_prefix = archive_prefix for mbox_name in "foobar", "/tmp/foobar", "schnorchz/foobar": archive_dir, archive_base = os.path.split(mbox_name) days = archivemail.options.days_old_max tm = time.localtime(time.time() - days*24*60*60) prefix = time.strftime(archive_prefix, tm) archive_name = os.path.join(archive_dir, prefix + archive_base) self.assertEqual(archive_name, archivemail.make_archive_name(mbox_name)) def tearDown(self): archivemail.options.quiet = False archivemail.options.archive_prefix = None class TestArchiveName(unittest.TestCase): def setUp(self): archivemail.options.quiet = True def testArchiveName(self): """test the --archive-name option""" archive_names = ("custom", ".withdot", "custom_%Y", "%Y/joe") mbox = "foobar" for name in archive_names: archivemail.options.archive_name = name days = archivemail.options.days_old_max tm = time.localtime(time.time() - days*24*60*60) name = time.strftime(name, tm) self.assertEqual(archivemail.make_archive_name(mbox), name) def tearDown(self): archivemail.options.quiet = False archivemail.options.archive_name = None class TestArchiveAffixes(unittest.TestCase): def setUp(self): self.mbox = "harbsch" self.archive_prefix = "wurbl+" self.archive_suffix = "+schronk&borsz" archivemail.options.quiet = True def testDefaultPrefix(self): """if no archive name affix is specified, the default archive suffix is appended""" self.assertEqual(archivemail.make_archive_name(self.mbox), self.mbox + archivemail.options.archive_default_suffix) def testPrefixKillsDefaultSuffix(self): """if an archive name prefix is specified, the default archive suffix is not appended""" archivemail.options.archive_prefix = self.archive_prefix self.assertEqual(archivemail.make_archive_name(self.mbox), self.archive_prefix + self.mbox) def testPrefixAndSuffix(self): """specifying both an archive name prefix and suffix works""" archivemail.options.archive_prefix = self.archive_prefix archivemail.options.archive_suffix = self.archive_suffix self.assertEqual(archivemail.make_archive_name(self.mbox), self.archive_prefix + self.mbox + self.archive_suffix) def tearDown(self): archivemail.options.archive_prefix = None archivemail.options.archive_suffix = None archivemail.options.quiet = False class TestArchiveHiddenMbox(unittest.TestCase): def setUp(self): archivemail.options.quiet = True self.mbox = ".upper.lower" def testHiddenMbox(self): """leading dots are stripped from the archive name when no prefix is added""" self.assertEqual(archivemail.make_archive_name(self.mbox), self.mbox.lstrip('.') + archivemail.options.archive_default_suffix) def testHiddenMboxPrefixedArchive(self): """no dots are stripped from the archive name when a prefix is added""" prefix = ".hidden_" archivemail.options.archive_prefix = prefix self.assertEqual(archivemail.make_archive_name(self.mbox), prefix + self.mbox) def tearDown(self): archivemail.options.quiet = False archivemail.options.archive_prefix = None class TestArchiveDryRun(TestArchive): """make sure the 'dry-run' option works""" def setUp(self): super(TestArchiveDryRun, self).setUp() archivemail.options.quiet = True archivemail.options.dry_run = True def testOld(self): """archiving an old mailbox with the 'dry-run' option""" self.make_old_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def tearDown(self): archivemail.options.dry_run = False archivemail.options.quiet = False super(TestArchiveDryRun, self).tearDown() class TestArchiveDelete(TestArchive): """make sure the 'delete' option works""" def setUp(self): super(TestArchiveDelete, self).setUp() archivemail.options.quiet = True archivemail.options.delete_old_mail = True def testNew(self): """archiving a new mailbox with the 'delete' option""" self.make_new_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testMixed(self): """archiving a mixed mailbox with the 'delete' option""" self.make_mixed_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testOld(self): """archiving an old mailbox with the 'delete' option""" self.make_old_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def tearDown(self): archivemail.options.delete_old_mail = False archivemail.options.quiet = False super(TestArchiveDelete, self).tearDown() class TestArchiveCopy(TestArchive): """make sure the 'copy' option works""" def setUp(self): super(TestArchiveCopy, self).setUp() archivemail.options.quiet = True archivemail.options.copy_old_mail = True def testNew(self): """archiving a new mailbox with the 'copy' option""" self.make_new_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testMixed(self): """archiving a mixed mailbox with the 'copy' option""" self.make_mixed_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testOld(self): """archiving an old mailbox with the 'copy' option""" self.make_old_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def tearDown(self): archivemail.options.copy_old_mail = False archivemail.options.quiet = False super(TestArchiveCopy, self).tearDown() class TestArchiveMboxFlagged(unittest.TestCase): """make sure the 'include_flagged' option works""" def setUp(self): archivemail.options.include_flagged = False archivemail.options.quiet = True def testOld(self): """by default, old flagged messages should not be archived""" msg = make_message(default_headers={"X-Status": "F"}, hours_old=24*181, wantobj=True) assert not archivemail.should_archive(msg) def testIncludeFlaggedNew(self): """new flagged messages should not be archived with include_flagged""" msg = make_message(default_headers={"X-Status": "F"}, hours_old=24*179, wantobj=True) assert not archivemail.should_archive(msg) def testIncludeFlaggedOld(self): """old flagged messages should be archived with include_flagged""" archivemail.options.include_flagged = True msg = make_message(default_headers={"X-Status": "F"}, hours_old=24*181, wantobj=True) assert archivemail.should_archive(msg) def tearDown(self): archivemail.options.include_flagged = False archivemail.options.quiet = False class TestArchiveMboxOutputDir(unittest.TestCase): """make sure that the 'output-dir' option works""" def setUp(self): archivemail.options.quiet = True def testOld(self): """archiving an old mailbox with a sepecified output dir""" for dir in "/just/a/path", "relative/path": archivemail.options.output_dir = dir archive_dir = archivemail.make_archive_name("/tmp/mbox") self.assertEqual(dir, os.path.dirname(archive_dir)) def tearDown(self): archivemail.options.quiet = False archivemail.options.output_dir = None class TestArchiveMboxUncompressed(TestArchive): """make sure that the 'no_compress' option works""" mbox_name = None new_mbox = None old_mbox = None copy_name = None def setUp(self): archivemail.options.quiet = True archivemail.options.no_compress = True super(TestArchiveMboxUncompressed, self).setUp() def testOld(self): """archiving an old mailbox uncompressed""" self.make_old_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testNew(self): """archiving a new mailbox uncompressed""" self.make_new_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testMixed(self): """archiving a mixed mailbox uncompressed""" self.make_mixed_mbox(messages=3) archivemail.archive(self.mbox) self.verify() def testOldExists(self): """archiving an old mailbox uncopressed with an existing archive""" self.make_old_mbox(messages=3, make_old_archive=True) archivemail.archive(self.mbox) self.verify() def tearDown(self): archivemail.options.quiet = False archivemail.options.no_compress = False super(TestArchiveMboxUncompressed, self).tearDown() class TestArchiveSize(unittest.TestCase): """check that the 'size' argument works""" def setUp(self): archivemail.options.quiet = True msg_text = make_message(hours_old=24*181) self.msg_size = len(msg_text) fp = cStringIO.StringIO(msg_text) self.msg = rfc822.Message(fp) def testSmaller(self): """giving a size argument smaller than the message""" archivemail.options.min_size = self.msg_size - 1 assert archivemail.should_archive(self.msg) def testBigger(self): """giving a size argument bigger than the message""" archivemail.options.min_size = self.msg_size + 1 assert not archivemail.should_archive(self.msg) def tearDown(self): archivemail.options.quiet = False archivemail.options.min_size = None class TestXIMAPMessage(TestArchive): """Test if IMAP pseudo messages in mboxes are properly handled.""" def setUp(self): super(TestXIMAPMessage, self).setUp() archivemail.options.quiet = True def testXIMAPMbox(self): """IMAP pseudo messages in an mbox are always preserved.""" self.good_mbox = make_mbox(hours_old=181*24, headers={'X-IMAP': 'dummytext'}, messages=1) self.good_archive = make_mbox(hours_old=181*24, messages=3) self.mbox = tempfile.mkstemp()[-1] shutil.copyfile(self.good_mbox, self.mbox) append_file(self.good_archive, self.mbox) archivemail.archive(self.mbox) self.verify() def tearDown(self): super(TestXIMAPMessage, self).tearDown() archivemail.options.quiet = False ############# Test archiving maildirs ############### class TestArchiveMailboxdir(TestCaseInTempdir): """Base class defining helper functions for doing test archive runs with maildirs.""" maildir = None # Maildir that will be processed by archivemail orig_maildir_obj = None # A backup copy of the maildir, a SimpleMaildir object remaining_msg = set() # Filenames of maildir messages that should be preserved number_archived = 0 # Number of messages that get archived orig_archive = None # An uncompressed copy of a pre-existing archive, # if one exists def setUp(self): super(TestArchiveMailboxdir, self).setUp() self.orig_maildir_obj = SimpleMaildir() def verify(self): self._verify_remaining() self._verify_archive() def _verify_remaining(self): """Verify that the preserved messages weren't altered.""" assert self.maildir # Compare maildir with backup object. dcmp = filecmp.dircmp(self.maildir, self.orig_maildir_obj.root) # Top-level has only directories cur, new, tmp and must be unchanged. self.assertEqual(dcmp.left_list, dcmp.right_list) found = set() for d in dcmp.common_dirs: dcmp2 = dcmp.subdirs[d] # We need to verify three things. # 1. directory is a subset of the original... assert not dcmp2.left_only # 2. all common files are identical... self.assertEqual(dcmp2.common_files, dcmp2.same_files) found = found.union([os.path.join(d, x) for x in dcmp2.common_files]) # 3. exactly the `new' messages (recorded in self.remaining_msg) # were preserved. self.assertEqual(found, self.remaining_msg) def _verify_archive(self): """Verify the archive correctness.""" # TODO: currently make_archive_name does not include the .gz suffix. # Is this something that should be fixed? archive = archivemail.make_archive_name(self.maildir) if archivemail.options.no_compress: iszipped = False else: archive += '.gz' iszipped = True if self.number_archived == 0: if self.orig_archive: assertEqualContent(archive, self.orig_archive, iszipped) else: assert not os.path.exists(archive) return fp_new = fp_archive = tmp_archive_name = None try: if self.orig_archive: new_size = os.path.getsize(archive) # Brute force: split archive in old and new part and verify the # parts separately. (Of course this destroys the archive.) fp_archive = open(archive, "r+") fp_archive.seek(self.orig_archive_size) fd, tmp_archive_name = tempfile.mkstemp() fp_new = os.fdopen(fd, "w") shutil.copyfileobj(fp_archive, fp_new) fp_new.close() fp_archive.truncate(self.orig_archive_size) fp_archive.close() assertEqualContent(archive, self.orig_archive, iszipped) new_archive = tmp_archive_name else: new_archive = archive if archivemail.options.no_compress: fp_archive = open(new_archive, "r") else: fp_archive = FixedGzipFile(new_archive, "r") mb = mailbox.UnixMailbox(fp_archive) found = 0 for msg in mb: self.verify_maildir_has_msg(self.orig_maildir_obj, msg) found += 1 self.assertEqual(found, self.number_archived) finally: if tmp_archive_name: os.remove(tmp_archive_name) if fp_new is not None: fp_new.close() if fp_archive is not None: fp_archive.close() def verify_maildir_has_msg(self, maildir, msg): """Assert that the given maildir has a copy of the rfc822 message.""" mid = msg['Message-Id'] # Complains if there is no message-id mdir_msg_str, mdir_flags = \ maildir.get_message_and_mbox_status(mid) mbox_flags = set(msg.get('status', '') + msg.get('x-status', '')) self.assertEqual(mdir_flags, mbox_flags) headers = filter(lambda h: msg.isheader(h) not in ('status', 'x-status'), msg.headers) headers = "".join(headers) msg.rewindbody() # Discard last mbox LF which is not part of the message. body = msg.fp.read()[:-1] msg_str = headers + os.linesep + body self.assertEqual(mdir_msg_str, msg_str) def add_messages(self, body=None, headers=None, hours_old=0, messages=1): for count in range(messages): msg = make_message(body, default_headers=headers, mkfrom=False, hours_old=hours_old) self.orig_maildir_obj.write(msg, new=False) def make_maildir(self, mkold, mknew, body=None, headers=None, messages=1, make_old_archive=False): mailbox_does_change = not (archivemail.options.dry_run or archivemail.options.copy_old_mail) archive_does_change = not (archivemail.options.dry_run or archivemail.options.delete_old_mail) if mknew: self.add_messages(body, headers, 179*24, messages) if archive_does_change and archivemail.options.archive_all: self.number_archived += messages if mailbox_does_change: self.remaining_msg = set(self.orig_maildir_obj.get_all_filenames()) if mkold: self.add_messages(body, headers, 181*24, messages) if archive_does_change: self.number_archived += messages if not mailbox_does_change: self.remaining_msg = set(self.orig_maildir_obj.get_all_filenames()) self.maildir = copy_maildir(self.orig_maildir_obj.root) if make_old_archive: archive = archivemail.make_archive_name(self.maildir) self.orig_archive = make_archive_and_plain_copy(archive) # FIXME: .gz extension handling is a mess II if not archivemail.options.no_compress: archive += '.gz' self.orig_archive_size = os.path.getsize(archive) class TestEmptyMaildir(TestCaseInTempdir): def setUp(self): super(TestEmptyMaildir, self).setUp() archivemail.options.quiet = True def testEmpty(self): """Archiving an empty maildir should not result in an archive.""" self.mdir = SimpleMaildir() archivemail.archive(self.mdir.root) assert not os.path.exists(self.mdir.root + '_archive.gz') def tearDown(self): super(TestEmptyMaildir, self).tearDown() archivemail.options.quiet = False class TestMaildir(TestArchiveMailboxdir): def setUp(self): super(TestMaildir, self).setUp() archivemail.options.quiet = True def testOld(self): self.make_maildir(True, False, messages=3) archivemail.archive(self.maildir) self.verify() def testNew(self): self.make_maildir(False, True, messages=3) archivemail.archive(self.maildir) self.verify() def testMixed(self): self.make_maildir(True, True, messages=3) archivemail.archive(self.maildir) self.verify() def testMixedExisting(self): self.make_maildir(True, True, messages=3, make_old_archive=True) archivemail.archive(self.maildir) self.verify() def tearDown(self): archivemail.options.quiet = False super(TestMaildir, self).tearDown() class TestMaildirPreserveUnread(TestCaseInTempdir): """Test if the preserve_unread option works with maildirs.""" def setUp(self): super(TestMaildirPreserveUnread, self).setUp() archivemail.options.quiet = True archivemail.options.preserve_unread = True def testOldRead(self): """--preserve-unread archives old read messages in a maildir.""" smd = SimpleMaildir("orig") msg = make_message(hours_old=24*181) smd.write(msg, new=False, flags='S') md = mailbox.Maildir(smd.root) msg_obj = md.next() assert archivemail.should_archive(msg_obj) def testOldUnread(self): """--preserve-unread preserves old unread messages in a maildir.""" smd = SimpleMaildir("orig") msg = make_message(hours_old=24*181) smd.write(msg, new=False) md = mailbox.Maildir(smd.root) msg_obj = md.next() assert not archivemail.should_archive(msg_obj) def tearDown(self): archivemail.options.quiet = False archivemail.options.preserve_unread = False super(TestMaildirPreserveUnread, self).tearDown() class TestMaildirAll(TestArchiveMailboxdir): def setUp(self): super(TestMaildirAll, self).setUp() archivemail.options.quiet = True archivemail.options.archive_all = True def testNew(self): """New maildir messages should be archived with --all""" self.add_messages(hours_old=24*181) md = mailbox.Maildir(self.orig_maildir_obj.root) msg_obj = md.next() assert archivemail.should_archive(msg_obj) def testOld(self): """Old maildir messages should be archived with --all""" self.add_messages(hours_old=24*179) md = mailbox.Maildir(self.orig_maildir_obj.root) msg_obj = md.next() assert archivemail.should_archive(msg_obj) def tearDown(self): super(TestMaildirAll, self).tearDown() archivemail.options.quiet = False archivemail.options.archive_all = False class TestMaildirDryRun(TestArchiveMailboxdir): def setUp(self): super(TestMaildirDryRun, self).setUp() archivemail.options.quiet = True archivemail.options.dry_run = True def testOld(self): """archiving an old maildir mailbox with the 'dry-run' option""" self.make_maildir(True, False) archivemail.archive(self.maildir) self.verify() def tearDown(self): super(TestMaildirDryRun, self).tearDown() archivemail.options.quiet = False archivemail.options.dry_run = False class TestMaildirDelete(TestArchiveMailboxdir): def setUp(self): super(TestMaildirDelete, self).setUp() archivemail.options.quiet = True archivemail.options.delete_old_mail = True def testOld(self): """archiving an old maildir mailbox with the 'delete' option""" self.make_maildir(True, False) archivemail.archive(self.maildir) self.verify() def testNew(self): """archiving a new maildir mailbox with the 'delete' option""" self.make_maildir(False, True) archivemail.archive(self.maildir) self.verify() def tearDown(self): super(TestMaildirDelete, self).tearDown() archivemail.options.quiet = False archivemail.options.delete_old_mail = False class TestMaildirCopy(TestArchiveMailboxdir): def setUp(self): super(TestMaildirCopy, self).setUp() archivemail.options.quiet = True archivemail.options.copy_old_mail = True def testOld(self): """archiving an old maildir mailbox with the 'copy' option""" self.make_maildir(True, False) archivemail.archive(self.maildir) self.verify() def testNew(self): """archiving a new maildir mailbox with the 'copy' option""" self.make_maildir(False, True) archivemail.archive(self.maildir) self.verify() def tearDown(self): super(TestMaildirCopy, self).tearDown() archivemail.options.quiet = False archivemail.options.copy_old_mail = False class TestArchiveMaildirFlagged(TestCaseInTempdir): """make sure the 'include_flagged' option works with maildir messages""" def setUp(self): super(TestArchiveMaildirFlagged, self).setUp() archivemail.options.include_flagged = False archivemail.options.quiet = True def testOld(self): """by default, old flagged maildir messages should not be archived""" smd = SimpleMaildir("orig") msg = make_message(hours_old=24*181) smd.write(msg, new=False, flags='F') md = mailbox.Maildir(smd.root) msg_obj = md.next() assert not archivemail.should_archive(msg_obj) def testIncludeFlaggedNew(self): """new flagged maildir messages should not be archived with include_flagged""" smd = SimpleMaildir("orig") msg = make_message(hours_old=24*179) smd.write(msg, new=False, flags='F') md = mailbox.Maildir(smd.root) msg_obj = md.next() assert not archivemail.should_archive(msg_obj) def testIncludeFlaggedOld(self): """old flagged maildir messages should be archived with include_flagged""" archivemail.options.include_flagged = True smd = SimpleMaildir("orig") msg = make_message(hours_old=24*181) smd.write(msg, new=False, flags='F') md = mailbox.Maildir(smd.root) msg_obj = md.next() assert archivemail.should_archive(msg_obj) def tearDown(self): super(TestArchiveMaildirFlagged, self).tearDown() archivemail.options.include_flagged = False archivemail.options.quiet = False class TestArchiveMaildirSize(TestCaseInTempdir): """check that the 'size' argument works with maildir messages""" def setUp(self): super(TestArchiveMaildirSize, self).setUp() archivemail.options.quiet = True msg = make_message(hours_old=24*181) self.msg_size = len(msg) smd = SimpleMaildir("orig") smd.write(msg, new=False) md = mailbox.Maildir(smd.root) self.msg_obj = md.next() def testSmaller(self): """giving a size argument smaller than the maildir message""" archivemail.options.min_size = self.msg_size - 1 assert archivemail.should_archive(self.msg_obj) def testBigger(self): """giving a size argument bigger than the maildir message""" archivemail.options.min_size = self.msg_size + 1 assert not archivemail.should_archive(self.msg_obj) def tearDown(self): super(TestArchiveMaildirSize, self).tearDown() archivemail.options.quiet = False archivemail.options.min_size = None ########## helper routines ############ def make_message(body=None, default_headers={}, hours_old=None, mkfrom=False, wantobj=False): headers = copy.copy(default_headers) if not headers: headers = {} headers['Message-Id'] = make_msgid() if not headers.has_key('Date'): time_message = time.time() - (60 * 60 * hours_old) headers['Date'] = time.asctime(time.localtime(time_message)) if not headers.has_key('From'): headers['From'] = "sender@dummy.domain" if not headers.has_key('To'): headers['To'] = "receipient@dummy.domain" if not headers.has_key('Subject'): headers['Subject'] = "This is the subject" if mkfrom and not headers.has_key('From_'): headers['From_'] = "%s %s" % (headers['From'], headers['Date']) if not body: body = "This is the message body" msg = "" if headers.has_key('From_'): msg = msg + ("From %s\n" % headers['From_']) del headers['From_'] for key in headers.keys(): if headers[key] is not None: msg = msg + ("%s: %s\n" % (key, headers[key])) msg = msg + "\n\n" + body + "\n\n" if not wantobj: return msg fp = cStringIO.StringIO(msg) return rfc822.Message(fp) def append_file(source, dest): """appends the file named 'source' to the file named 'dest'""" assert os.path.isfile(source) assert os.path.isfile(dest) read = open(source, "r") write = open(dest, "a+") shutil.copyfileobj(read,write) read.close() write.close() def make_mbox(body=None, headers=None, hours_old=0, messages=1): assert tempfile.tempdir fd, name = tempfile.mkstemp() file = os.fdopen(fd, "w") for count in range(messages): msg = make_message(body=body, default_headers=headers, mkfrom=True, hours_old=hours_old) file.write(msg) file.close() return name def make_archive_and_plain_copy(archive_name): """Make an mbox archive of the given name like archivemail may have created it. Also make an uncompressed copy of this archive and return its name.""" copy_fd, copy_name = tempfile.mkstemp() copy_fp = os.fdopen(copy_fd, "w") if archivemail.options.no_compress: fd = os.open(archive_name, os.O_WRONLY|os.O_EXCL|os.O_CREAT) fp = os.fdopen(fd, "w") else: archive_name += ".gz" fd = os.open(archive_name, os.O_WRONLY|os.O_EXCL|os.O_CREAT) rawfp = os.fdopen(fd, "w") fp = gzip.GzipFile(fileobj=rawfp) for count in range(3): msg = make_message(hours_old=24*360) fp.write(msg) copy_fp.write(msg) fp.close() copy_fp.close() if not archivemail.options.no_compress: rawfp.close() return copy_name def copy_maildir(maildir, prefix="tmp"): """Create a copy of the given maildir and return the absolute path of the new direcory.""" newdir = tempfile.mkdtemp(prefix=prefix) for d in "cur", "new", "tmp": shutil.copytree(os.path.join(maildir, d), os.path.join(newdir, d)) return newdir def assertEqualContent(firstfile, secondfile, zippedfirst=False): """Verify that the two files exist and have identical content. If zippedfirst is True, assume that firstfile is gzip-compressed.""" assert os.path.exists(firstfile) assert os.path.exists(secondfile) if zippedfirst: try: fp1 = gzip.GzipFile(firstfile, "r") fp2 = open(secondfile, "r") assert cmp_fileobj(fp1, fp2) finally: fp1.close() fp2.close() else: assert filecmp.cmp(firstfile, secondfile, shallow=0) def cmp_fileobj(fp1, fp2): """Return if reading the fileobjects yields identical content.""" bufsize = 8192 while True: b1 = fp1.read(bufsize) b2 = fp2.read(bufsize) if b1 != b2: return False if not b1: return True if __name__ == "__main__": unittest.main()