Python LogFileMark.readline方法代码示例

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_archive_lock_used(self):
     # Test that locking the maildir when adding works as a failure here
     # could mean we lose mail.
     lock_file = os.path.join(
         config.LOCK_DIR, '{0}-maildir.lock'.format(
             self._mlist.fqdn_listname))
     with Lock(lock_file):
         # Acquire the archiver lock, then make sure the archiver logs the
         # fact that it could not acquire the lock.
         archive_thread = threading.Thread(
             target=Prototype.archive_message,
             args=(self._mlist, self._msg))
         mark = LogFileMark('mailman.error')
         archive_thread.run()
         # Test that the archiver output the correct error.
         line = mark.readline()
         # XXX 2012-03-15 BAW: we really should remove timestamp prefixes
         # from the loggers when under test.
         self.assertTrue(line.endswith(
             'Unable to acquire prototype archiver lock for {0}, '
             'discarding: {1}\n'.format(
                 self._mlist.fqdn_listname,
                 self._msg.get('message-id'))))
     # Check that the message didn't get archived.
     created_files = self._find(config.ARCHIVE_DIR)
     self.assertEqual(self._expected_dir_structure, created_files)

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
    def test_no_detectable_bounce_addresses(self):
        # A bounce message was received, but no addresses could be detected.
        # A message will be logged in the bounce log though, and the message
        # can be forwarded to someone who can do something about it.
        self._mlist.forward_unrecognized_bounces_to = (
            UnrecognizedBounceDisposition.site_owner)
        bogus = message_from_string("""\
From: [email protected]
To: [email protected]
Message-Id: <third>

""")
        self._bounceq.enqueue(bogus, self._msgdata)
        mark = LogFileMark('mailman.bounce')
        self._runner.run()
        self.assertEqual(len(get_queue_messages('bounces')), 0)
        events = list(self._processor.events)
        self.assertEqual(len(events), 0)
        line = mark.readline()
        self.assertEqual(
            line[-51:-1],
            'Bounce message w/no discernable addresses: <third>')
        # Here's the forwarded message to the site owners.
        forwards = get_queue_messages('virgin')
        self.assertEqual(len(forwards), 1)
        self.assertEqual(forwards[0].msg['to'], '[email protected]')

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_bad_configuration_line(self):
     # Take a mark on the error log file.
     mark = LogFileMark('mailman.error')
     # A bad value in [antispam]header_checks should just get ignored, but
     # with an error message logged.
     chain = config.chains['header-match']
     # The links are created dynamically; the rule names will all start
     # with the same prefix, but have a variable suffix.  The actions will
     # all be to jump to the named chain.  Do these checks now, while we
     # collect other useful information.
     post_checks = []
     saw_any_rule = False
     for link in chain.get_links(self._mlist, Message(), {}):
         if link.rule.name == 'any':
             saw_any_rule = True
             self.assertEqual(link.action, LinkAction.jump)
         elif saw_any_rule:
             raise AssertionError("'any' rule was not last")
         else:
             self.assertEqual(link.rule.name[:13], 'header-match-')
             self.assertEqual(link.action, LinkAction.defer)
             post_checks.append((link.rule.header, link.rule.pattern))
     self.assertListEqual(post_checks, [
         ('Foo', 'foo'),
         ('Bar', 'bar'),
         ])
     # Check the error log.
     self.assertEqual(mark.readline()[-77:-1],
                      'Configuration error: [antispam]header_checks '
                      'contains bogus line: A-bad-line')

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_connect_with_socket_failure(self, class_mock):
     self._nntpq.enqueue(self._msg, {}, listname='[email protected]')
     mark = LogFileMark('mailman.error')
     self._runner.run()
     log_message = mark.readline()[:-1]
     self.assertTrue(log_message.endswith(
         'NNTP socket error for [email protected]'))

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_discarding_pipeline(self):
     # If a handler in the pipeline raises DiscardMessage, the message will
     # be thrown away, but with a log message.
     mark = LogFileMark('mailman.vette')
     process(self._mlist, self._msg, {}, 'test-discarding')
     line = mark.readline()[:-1]
     self.assertTrue(line.endswith(
         '<ant> discarded by "test-discarding" pipeline handler '
         '"discarding": by test handler'))

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_header_matches_invalid_re(self):
     # Check that an invalid regular expression pattern is skipped.
     self._pckdict['header_filter_rules'] = [
         ('SomeHeaderName: *invalid-re', 3, False),
         ]
     error_log = LogFileMark('mailman.error')
     self._import()
     self.assertListEqual(self._mlist.header_matches, [])
     self.assertIn('Skipping header_filter rule because of an invalid '
                   'regular expression', error_log.readline())

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_header_matches_header_only(self):
     # Check that an empty pattern is skipped.
     self._pckdict['header_filter_rules'] = [
         ('SomeHeaderName', 3, False),
         ]
     error_log = LogFileMark('mailman.error')
     self._import()
     self.assertListEqual(self._mlist.header_matches, [])
     self.assertIn('Unsupported header_filter_rules pattern',
                   error_log.readline())

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_header_matches_anything(self):
     # Check that a wild card header pattern is skipped.
     self._pckdict['header_filter_rules'] = [
         ('.*', 7, False),
         ]
     error_log = LogFileMark('mailman.error')
     self._import()
     self.assertListEqual(self._mlist.header_matches, [])
     self.assertIn('Unsupported header_filter_rules pattern',
                   error_log.readline())

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_maybe_forward_discard(self):
     # When forward_unrecognized_bounces_to is set to discard, no bounce
     # messages are forwarded.
     self._mlist.forward_unrecognized_bounces_to = (
         UnrecognizedBounceDisposition.discard)
     # The only artifact of this call is a log file entry.
     mark = LogFileMark('mailman.bounce')
     maybe_forward(self._mlist, self._msg)
     get_queue_messages('virgin', expected_count=0)
     line = mark.readline()
     self.assertEqual(
         line[-40:-1],
         'Discarding unrecognized bounce: <first>')

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_rejecting_pipeline(self):
     # If a handler in the pipeline raises DiscardMessage, the message will
     # be thrown away, but with a log message.
     mark = LogFileMark('mailman.vette')
     process(self._mlist, self._msg, {}, 'test-rejecting')
     line = mark.readline()[:-1]
     self.assertTrue(line.endswith(
         '<ant> rejected by "test-rejecting" pipeline handler '
         '"rejecting": by test handler'))
     # In the rejection case, the original message will also be in the
     # virgin queue.
     items = get_queue_messages('virgin', expected_count=1)
     self.assertEqual(str(items[0].msg['subject']), 'a test')

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_header_matches_duplicate(self):
     # Check that duplicate patterns don't cause tracebacks.
     self._pckdict['header_filter_rules'] = [
         ('SomeHeaderName: test-pattern', 3, False),
         ('SomeHeaderName: test-pattern', 2, False),
         ]
     error_log = LogFileMark('mailman.error')
     self._import()
     self.assertListEqual(
         [(hm.header, hm.pattern, hm.chain)
          for hm in self._mlist.header_matches],
         [('someheadername', 'test-pattern', 'discard')]
         )
     self.assertIn('Skipping duplicate header_filter rule',
                   error_log.readline())

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_error_with_numeric_port(self):
     # Test the code path where a socket.error is raised in the delivery
     # function, and the MTA port is set to zero.  The only real effect of
     # that is a log message.  Start by opening the error log and reading
     # the current file position.
     mark = LogFileMark('mailman.error')
     self._outq.enqueue(self._msg, {}, listid='test.example.com')
     with configuration('mta', smtp_port=2112):
         self._runner.run()
     line = mark.readline()
     # The log line will contain a variable timestamp, the PID, and a
     # trailing newline.  Ignore these.
     self.assertEqual(
         line[-53:-1],
         'Cannot connect to SMTP server localhost on port 2112')

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_get_moderator_approval_log_on_hold(self):
     # When the subscription is held for moderator approval, a message is
     # logged.
     mark = LogFileMark('mailman.subscribe')
     self._mlist.subscription_policy = SubscriptionPolicy.moderate
     anne = self._user_manager.create_address(self._anne)
     workflow = SubscriptionWorkflow(self._mlist, anne,
                                     pre_verified=True,
                                     pre_confirmed=True)
     # Consume the entire state machine.
     list(workflow)
     self.assertIn(
        '[email protected]: held subscription request from [email protected]',
        mark.readline()
        )

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_header_matches_unsupported_action(self):
     # Check that unsupported actions are skipped.
     for action_num in (1, 4, 5):
         self._pckdict['header_filter_rules'] = [
             ('HeaderName: test-re', action_num, False),
             ]
         error_log = LogFileMark('mailman.error')
         self._import()
         self.assertListEqual(self._mlist.header_matches, [])
         self.assertIn('Unsupported header_filter_rules action',
                       error_log.readline())
         # Avoid a useless warning.
         for member in self._mlist.members.members:
             member.unsubscribe()
         for member in self._mlist.owners.members:
             member.unsubscribe()

# 需要导入模块: from mailman.testing.helpers import LogFileMark [as 别名]
# 或者: from mailman.testing.helpers.LogFileMark import readline [as 别名]
 def test_connect_with_other_failure(self, class_mock):
     # In this failure mode, the message stays queued, so we can only run
     # the nntp runner once.
     def once(runner):
         # I.e. stop immediately, since the queue will not be empty.
         return True
     runner = make_testable_runner(nntp.NNTPRunner, 'nntp', predicate=once)
     self._nntpq.enqueue(self._msg, {}, listid='test.example.com')
     mark = LogFileMark('mailman.error')
     runner.run()
     log_message = mark.readline()[:-1]
     self.assertTrue(log_message.endswith(
         'NNTP unexpected exception for [email protected]'))
     items = get_queue_messages('nntp', expected_count=1)
     self.assertEqual(items[0].msgdata['listid'], 'test.example.com')
     self.assertEqual(items[0].msg['subject'], 'A newsgroup posting')