gurgitate-mail 1.8.4 → 1.8.5

data/test/gurgitate-test.rb

@@ -0,0 +1,62 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'stringio'
+require 'fileutils'
+require 'pathname'
+require 'irb'
+require "./gurgitate-mail"
+
+class GurgitateTest < Test::Unit::TestCase
+	def setup
+        currentdir = Pathname.new(File.join(File.dirname(__FILE__), 
+                                         "..")).realpath.to_s
+        @testdir = File.join(currentdir,"test-data")
+        testdir = @testdir
+        @folders = File.join(@testdir,"folders")
+        folders = @folders
+        FileUtils.rmtree @testdir if File.exists? @testdir
+        Dir.mkdir @testdir
+        Dir.mkdir @folders
+		m = StringIO.new("From: me\nTo: you\nSubject: test\n\nHi.\n")
+        @gurgitate = nil
+		@gurgitate = Gurgitate::Gurgitate.new(m)
+
+        @sendmail = File.join(@testdir, "bin", "sendmail")
+        sendmail = @sendmail
+
+        Dir.mkdir File.join(@testdir,"bin")
+
+        File.open(@sendmail,"w") do |f|
+            f.puts "#!/bin/sh"
+            f.puts "exec > #{@testdir}/sendmail_output 2>&1"
+            f.puts 'echo "$@"'
+            f.puts 'cat'
+        end
+
+        FileUtils.chmod 0755, @sendmail
+
+        @gurgitate.instance_eval do 
+            sendmail "/bin/cat" 
+            homedir testdir
+            spooldir testdir
+            spoolfile File.join(testdir, "default")
+            maildir folders
+        end
+        @spoolfile = File.join(testdir, "default")
+	end
+
+    def maildirmake mailbox # per the command
+        FileUtils.mkdir mailbox
+        %w/cur tmp new/.each do |subdir|
+            FileUtils.mkdir File.join(mailbox, subdir)
+        end
+    end
+
+    def teardown
+        FileUtils.rmtree @testdir
+    end
+
+    def test_truth
+        assert true
+    end
+end

data/{test.rb → test/runtests.rb}

@@ -7,6 +7,7 @@
 require 'test/unit'
 require 'test/unit/ui/console/testrunner'
 require 'stringio'
+require 'pathname'
 
 def runtests(testcases)
     testcases.each do |testcase|
@@ -14,7 +15,9 @@ def runtests(testcases)
     end
 end
 
-testcases = Dir[File.join("tests","test_*")].map do |file|
+testpath = Pathname.new(__FILE__).dirname.realpath
+
+testcases = Dir[File.join(testpath,"test_*")].map do |file|
     load file
     eval("TC_" + File.basename(file,".rb").sub(/^test_/,'').capitalize)
 end

data/test/test_configuration.rb

@@ -0,0 +1,35 @@
+require "test/gurgitate-test"
+require "etc"
+
+class TC_Configuration < GurgitateTest
+    def test_default_configuration
+        assert_equal Gurgitate::Deliver::MBox, @gurgitate.folderstyle
+        assert_equal @folders, @gurgitate.maildir
+        assert_equal @spoolfile, @gurgitate.spoolfile
+        assert_equal @testdir, @gurgitate.homedir
+    end
+
+    def test_changing_folderstyle_to_maildir
+        assert_nothing_raised do
+            @gurgitate.folderstyle Gurgitate::Deliver::Maildir
+        end
+        assert_equal File.join(@testdir,"Maildir"), @gurgitate.spoolfile
+        assert_equal File.join(@testdir,"Maildir"), @gurgitate.maildir
+    end
+
+    def test_changing_folderstyle_to_mbox
+        assert_nothing_raised do
+            @gurgitate.folderstyle Gurgitate::Deliver::MBox
+        end
+
+        assert_equal "/var/spool/mail", @gurgitate.spooldir
+        assert_equal File.join("/var/spool/mail",
+                               Etc.getpwuid.name), @gurgitate.spoolfile
+    end
+
+    def test_illegal_folderstyle_syntax
+        assert_raises ArgumentError do
+            @gurgitate.folderstyle 1, 2, 3
+        end
+    end
+end

data/test/test_delivery.rb

@@ -0,0 +1,213 @@
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'stringio'
+require 'fileutils'
+require 'pathname'
+require 'irb'
+require "./gurgitate-mail"
+require "test/gurgitate-test"
+
+class TC_Delivery < GurgitateTest
+    #************************************************************************
+    # tests
+    #************************************************************************
+
+    def test_basic_delivery
+        assert_nothing_raised do
+            @gurgitate.process { nil }
+        end
+        assert File.exists?(@spoolfile)
+    end
+
+    def test_detect_mbox
+        Dir.mkdir(@testdir) rescue nil
+        File.open(@spoolfile, File::WRONLY | File::CREAT) do |f|
+            f.print ""
+        end
+
+        assert_nothing_raised do
+            @gurgitate.process { nil }
+        end
+
+        assert File.exists?(@spoolfile)
+    end
+
+    def test_detect_maildir
+        maildirmake @spoolfile
+
+        assert_nothing_raised do
+            @gurgitate.process { nil }
+        end
+
+        assert Dir[File.join(@spoolfile,"new","*")].length > 0
+        assert File.exists?(Dir[File.join(@spoolfile,"new","*")][0])
+        FileUtils.rmtree @spoolfile
+        teardown
+        test_detect_mbox
+        setup
+    end
+
+    def test_save_folders
+        assert_nothing_raised do
+            @gurgitate.process do
+                save "=test"
+                break
+            end
+        end
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).file?
+    end
+
+    def test_save_guess_maildir
+        maildirmake File.join(@folders,"test")
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).directory?
+        assert File.exists?(File.join(@folders, "test", "new"))
+
+        assert_equal 0, Dir[File.join(@folders, "test", "new", "*")].length
+        assert_equal 0, Dir[File.join(@folders, "test", "cur", "*")].length
+
+        assert_nothing_raised do
+            @gurgitate.process do
+                save "=test"
+                break
+            end
+        end
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).directory?
+        assert File.exists?(File.join(@folders, "test", "new"))
+        assert File.stat(File.join(@folders, "test","new")).directory?
+        assert_equal 0, Dir[File.join(@folders, "test", "cur", "*")].length
+        assert_equal 1, Dir[File.join(@folders, "test", "new", "*")].length
+    end
+
+    def test_save_maildir_collision
+        maildirmake File.join(@folders,"test")
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).directory?
+        assert File.exists?(File.join(@folders, "test", "new"))
+
+        assert_equal 0, Dir[File.join(@folders, "test", "new", "*")].length
+        assert_equal 0, Dir[File.join(@folders, "test", "cur", "*")].length
+
+        assert_nothing_raised do
+            @gurgitate.process do
+                save "=test"
+                save "=test"
+                break
+            end
+        end
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).directory?
+        assert File.exists?(File.join(@folders, "test", "new"))
+        assert File.stat(File.join(@folders, "test","new")).directory?
+        assert_equal 0, Dir[File.join(@folders, "test", "cur", "*")].length
+        assert_equal 2, Dir[File.join(@folders, "test", "new", "*")].length
+    end
+
+    def test_save_create_maildir
+        maildirmake @spoolfile
+
+        assert_nothing_raised do
+            @gurgitate.process do
+                @folderstyle = Gurgitate::Deliver::Maildir
+                @maildir = @spoolfile
+                save "=test"
+                break
+            end
+        end
+
+        assert File.exists?(File.join(@spoolfile, ".test"))
+        assert File.stat(File.join(@spoolfile, ".test")).directory?
+        assert File.exists?(File.join(@spoolfile, ".test", "new"))
+        assert File.stat(File.join(@spoolfile, ".test","new")).directory?
+        assert_equal 0, Dir[File.join(@spoolfile, ".test", "cur", "*")].length
+        assert_equal 1, Dir[File.join(@spoolfile, ".test", "new", "*")].length
+    end
+
+    def test_save_bad_filename
+        assert_nothing_raised do
+            @gurgitate.process do
+                save "testing"
+            end
+        end
+
+        assert File.exists?(@spoolfile)
+        assert !File.exists?("testing")
+    end
+
+    def test_cannot_save
+        FileUtils.touch @spoolfile
+        FileUtils.chmod 0, @spoolfile
+
+        assert_raises Errno::EACCES do
+            @gurgitate.process do 
+                nil
+            end
+        end
+    end
+
+    def test_mailbox_heuristics_mbox
+        @gurgitate.instance_eval do
+            @folderstyle = nil
+        end
+
+        assert_nothing_raised do
+            @gurgitate.process do
+                save "=test"
+            end
+        end
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).file?
+    end
+
+    def test_mailbox_heuristics_maildir
+        @gurgitate.instance_eval do
+            @folderstyle = nil
+        end
+
+        assert_nothing_raised do
+            @gurgitate.process do
+                save "=test/"
+            end
+        end
+
+        assert File.exists?(File.join(@folders, "test"))
+        assert File.stat(File.join(@folders, "test")).directory?
+        assert File.exists?(File.join(@folders, "test", "new"))
+        assert File.stat(File.join(@folders, "test","new")).directory?
+        assert_equal 0, Dir[File.join(@folders, "test", "cur", "*")].length
+        assert_equal 1, Dir[File.join(@folders, "test", "new", "*")].length
+    end
+
+    def test_message_parsed_correctly
+        assert_equal("From: me",@gurgitate.header("From"))
+        assert_equal("To: you", @gurgitate.header("To"))
+        assert_equal("Subject: test", @gurgitate.header("Subject"))
+        assert_equal("Hi.\n", @gurgitate.body, "Message body is wrong")
+    end
+
+    def test_message_written_correctly
+        test_message_parsed_correctly
+        assert_nothing_raised do
+            @gurgitate.process
+        end
+
+        mess=nil
+        assert_nothing_raised do
+            mess = Gurgitate::Mailmessage.new(File.read(@spoolfile))
+        end
+
+        assert_equal("From: me", mess.header("From"), "From header is wrong")
+        assert_equal("To: you", mess.header("To"), "To header is wrong")
+        assert_equal("Hi.\n", mess.body, "Body is wrong")
+        assert_equal("Subject: test", mess.header("Subject"), "Subject header wrong")
+    end
+end
+

data/test/test_header.rb

@@ -0,0 +1,154 @@
+#!/opt/bin/ruby -w
+
+#------------------------------------------------------------------------
+# 
+#------------------------------------------------------------------------
+
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'stringio'
+
+class TC_Header < Test::Unit::TestCase
+
+    def setup
+        require './gurgitate-mail'
+    end
+
+    # def teardown
+    # end
+
+    def test_simple_header
+        h=Gurgitate::Header.new("From: fromheader@example.com")
+        assert_equal(h.name,"From", "Simple header name is From")
+        assert_equal(h.contents,"fromheader@example.com", 
+            "Contents is fromheader@example.com")
+        assert_equal(h.value,"fromheader@example.com", 
+            "Contents is fromheader@example.com")
+    end
+
+    def test_canonicalize_crashing
+        String.class_eval do
+            alias old_capitalize capitalize
+            def capitalize
+                raise RuntimeError
+            end
+        end
+
+        test_simple_header
+
+        String.class_eval do
+            alias capitalize old_capitalize
+        end
+    end
+
+
+    # This is an illegal header that turns up in spam sometimes.
+    # Crashing when you get spam is bad.
+    def test_malcapitalized_header
+        h=Gurgitate::Header.new("FROM: fromheader@example.com")
+        assert_equal(h.name,"From", "Badly-capitalized header is From")
+        assert_equal(h.contents,"fromheader@example.com", 
+            "Badly-capitalized header")
+        assert_equal(h.value,"fromheader@example.com", 
+            "Badly-capitalized header")
+    end
+
+    # I got a message with "X-Qmail-Scanner-1.19" once.  I hate whoever did
+    # that.
+    def test_dot_in_header
+        h=Gurgitate::Header.new("From.Header: fromheader@example.com")
+        assert_equal(h.name, "From.header", 
+                     "header with dot in it is From.header")
+        assert_equal(h.contents, "fromheader@example.com",
+                     "header with dot in it")
+        assert_equal(h.value, "fromheader@example.com",
+                     "header with dot in it")
+    end
+
+    # Dammit!  My new "anything goes" header parser was parsing too much
+    def test_delivered_to
+        h=Gurgitate::Header.new("Delivered-To: dagbrown@example.com")
+        assert_equal("Delivered-To", h.name)
+        assert_equal "dagbrown@example.com", h.contents
+        assert_equal "dagbrown@example.com", h.value
+    end
+
+    # This is another particularly horrible spamware-generated not-a-header.
+    def test_header_that_starts_with_hyphen
+        h=Gurgitate::Header.new("-From: -fromheader@example.com")
+        assert_equal(h.name, "-From",
+                     "header with leading hyphen is -From")
+        assert_equal(h.contents, "-fromheader@example.com",
+                     "header with leading hyphen")
+        assert_equal(h.value, "-fromheader@example.com",
+                     "header with leading hyphen")
+    end
+
+    # This is another illegal header that turns up in spam sometimes.
+    # Crashing when you get spam is bad.
+    def test_nonalphabetic_initial_char_header
+        h=Gurgitate::Header.new("2From: fromheader@example.com")
+        assert_equal(h.name,"2from", 
+                     "Header that starts with illegal char is 2From")
+        assert_equal(h.contents, "fromheader@example.com",
+                     "Header that starts with illegal char")
+        assert_equal(h.value, "fromheader@example.com",
+                     "Header that starts with illegal char")
+    end
+
+    def test_bad_headers
+        assert_raises(Gurgitate::IllegalHeader,"Empty name") {
+            h=Gurgitate::Header.new(": Hi")
+        }
+#         assert_raises(Gurgitate::IllegalHeader,"Empty header contents") {
+#             h=Gurgitate::Header.new("From: ")
+#         }
+        assert_raises(Gurgitate::IllegalHeader,"Bad header syntax") {
+            h=Gurgitate::Header.new("This is completely wrong")
+        }
+    end
+    def test_extending_header
+        h=Gurgitate::Header.new("From: fromheader@example.com")
+        h << "  (Dave Brown)"
+        assert_equal(h.name,"From","Extended header is From")
+        assert_equal(h.contents,"fromheader@example.com\n  (Dave Brown)",
+            "Extended header contains all data")
+        assert_equal(h.contents,h.value,"Contents same as value")
+    end
+
+    def test_empty_header_with_extension
+        h=Gurgitate::Header.new("From:")
+        h << " fromheader@example.com"
+        assert_equal("From",h.name,"Empty extended header is From")
+        assert_equal("\n fromheader@example.com", h.contents,
+                     "Empty extended header contains all data")
+        assert_equal(h.contents, h.value, "Contents same as value")
+    end
+
+    def test_changing_header
+        h=Gurgitate::Header.new("From: fromheader@example.com")
+        h.contents="anotherfromheader@example.com"
+        assert_equal(h.contents,"anotherfromheader@example.com",
+            "header contents contains new data")
+    end
+
+    def test_tabseparated_header
+        h=Gurgitate::Header.new("From:\tfromheader@example.com")
+        assert_equal(h.name,"From","Tabseparated header is From (bug#154)")
+        assert_equal(h.contents,"fromheader@example.com",
+            "Tabseparated header's contents are correct (bug#154)")
+        assert_equal(h.contents,h.value,"Contents same as value (bug#154)")
+    end
+
+    def test_conversion_to_String
+        h=Gurgitate::Header.new("From: fromheader@example.com")
+        assert_equal(h.to_s,"From: fromheader@example.com", "Conversion to string returns input")
+    end
+
+    def test_regex_match
+        h=Gurgitate::Header.new("From: fromheader@example.com")
+        assert_equal(0,h.matches(/fromheader/),"Matches regex that would match input")
+        assert_equal(nil,h.matches(/notininput/),"Does not match regex that would not match input")
+    end
+end
+