sup 1.2 → 1.4

data/test/test_crypto.rb

@@ -38,14 +38,15 @@ class TestCryptoManager < Minitest::Test
         @path = Dir.mktmpdir
         Redwood::HookManager.init File.join(@path, 'hooks')
 
-        am = {:default=> {name: "test", email: @from_email, alternates: [@from_email_ecc]}}
-        Redwood::AccountManager.init am
+        account = {
+          :name => +"test",
+          :email => @from_email.dup,
+          :alternates => [@from_email_ecc.dup],
+          :sendmail => "/bin/false",
+        }
+        Redwood::AccountManager.init :default => account
 
         Redwood::CryptoManager.init
-
-        if not CryptoManager.have_crypto?
-          warn "No crypto set up, crypto will not be tested. Reason: #{CryptoManager.not_working_reason}"
-        end
     end
 
     def teardown
@@ -58,90 +59,132 @@ class TestCryptoManager < Minitest::Test
     end
 
     def test_sign
-        if CryptoManager.have_crypto? then
-            signed = CryptoManager.sign @from_email,@to_email,"ABCDEFG"
-            assert_instance_of RMail::Message, signed
-            assert_equal("multipart/signed; protocol=application/pgp-signature; micalg=pgp-sha256",
-                         signed.header["Content-Type"])
-            assert_equal "ABCDEFG", signed.body[0]
-            assert signed.body[1].body.length > 0 , "signature length must be > 0"
-            assert (signed.body[1].body.include? "-----BEGIN PGP SIGNATURE-----") , "Expecting PGP armored data"
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      signed = CryptoManager.sign @from_email,@to_email,"ABCDEFG"
+      assert_instance_of RMail::Message, signed
+      assert_equal("multipart/signed; protocol=application/pgp-signature; micalg=pgp-sha256",
+                   signed.header["Content-Type"])
+      assert_equal "ABCDEFG", signed.body[0]
+      assert signed.body[1].body.length > 0 , "signature length must be > 0"
+      assert (signed.body[1].body.include? "-----BEGIN PGP SIGNATURE-----") , "Expecting PGP armored data"
     end
 
     def test_sign_nested_parts
-        if CryptoManager.have_crypto? then
-            body = RMail::Message.new
-            body.header["Content-Disposition"] = "inline"
-            body.body = "ABCDEFG"
-            payload = RMail::Message.new
-            payload.header["MIME-Version"] = "1.0"
-            payload.add_part body
-            payload.add_part RMail::Message.make_attachment "attachment", "text/plain", nil, "attachment.txt"
-            signed = CryptoManager.sign @from_email, @to_email, payload
-            ## The result is a multipart/signed containing a multipart/mixed.
-            ## There should be a MIME-Version header on the top-level
-            ## multipart/signed message, but *not* on the enclosed
-            ## multipart/mixed part.
-            assert_equal 1, signed.to_s.scan(/MIME-Version:/).size
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      body = RMail::Message.new
+      body.header["Content-Disposition"] = +"inline"
+      body.body = "ABCDEFG"
+      payload = RMail::Message.new
+      payload.header["MIME-Version"] = +"1.0"
+      payload.add_part body
+      payload.add_part RMail::Message.make_attachment "attachment", "text/plain", nil, "attachment.txt"
+      signed = CryptoManager.sign @from_email, @to_email, payload
+      ## The result is a multipart/signed containing a multipart/mixed.
+      ## There should be a MIME-Version header on the top-level
+      ## multipart/signed message, but *not* on the enclosed
+      ## multipart/mixed part.
+      assert_equal 1, signed.to_s.scan(/MIME-Version:/).size
     end
 
     def test_encrypt
-        if CryptoManager.have_crypto? then
-            encrypted = CryptoManager.encrypt @from_email, [@to_email], "ABCDEFG"
-            assert_instance_of RMail::Message, encrypted
-            assert (encrypted.body[1].body.include? "-----BEGIN PGP MESSAGE-----") , "Expecting PGP armored data"
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      encrypted = CryptoManager.encrypt @from_email, [@to_email], "ABCDEFG"
+      assert_instance_of RMail::Message, encrypted
+      assert (encrypted.body[1].body.include? "-----BEGIN PGP MESSAGE-----") , "Expecting PGP armored data"
     end
 
     def test_sign_and_encrypt
-        if CryptoManager.have_crypto? then
-            encrypted = CryptoManager.sign_and_encrypt @from_email, [@to_email], "ABCDEFG"
-            assert_instance_of RMail::Message, encrypted
-            assert (encrypted.body[1].body.include? "-----BEGIN PGP MESSAGE-----") , "Expecting PGP armored data"
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      encrypted = CryptoManager.sign_and_encrypt @from_email, [@to_email], "ABCDEFG"
+      assert_instance_of RMail::Message, encrypted
+      assert (encrypted.body[1].body.include? "-----BEGIN PGP MESSAGE-----") , "Expecting PGP armored data"
     end
 
     def test_decrypt
-        if CryptoManager.have_crypto? then
-            encrypted = CryptoManager.encrypt @from_email, [@to_email], "ABCDEFG"
-            assert_instance_of RMail::Message, encrypted
-            assert_instance_of String, (encrypted.body[1].body)
-            decrypted = CryptoManager.decrypt encrypted.body[1], true
-            assert_instance_of Array, decrypted
-            assert_instance_of Chunk::CryptoNotice, decrypted[0]
-            assert_instance_of Chunk::CryptoNotice, decrypted[1]
-            assert_instance_of RMail::Message, decrypted[2]
-            assert_equal "ABCDEFG" , decrypted[2].body
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      encrypted = CryptoManager.encrypt @from_email, [@to_email], "ABCDEFG"
+      assert_instance_of RMail::Message, encrypted
+      assert_instance_of String, (encrypted.body[1].body)
+      decrypted = CryptoManager.decrypt encrypted.body[1], true
+      assert_instance_of Array, decrypted
+      assert_instance_of Chunk::CryptoNotice, decrypted[0]
+      assert_instance_of Chunk::CryptoNotice, decrypted[1]
+      assert_instance_of RMail::Message, decrypted[2]
+      assert_equal "ABCDEFG" , decrypted[2].body
+    end
+
+    def test_decrypt_and_verify
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      encrypted = CryptoManager.sign_and_encrypt @from_email, [@to_email], "ABCDEFG"
+      assert_instance_of RMail::Message, encrypted
+      assert_instance_of String, (encrypted.body[1].body)
+      decrypted = CryptoManager.decrypt encrypted.body[1], true
+      assert_instance_of Array, decrypted
+      assert_instance_of Chunk::CryptoNotice, decrypted[0]
+      assert_instance_of Chunk::CryptoNotice, decrypted[1]
+      assert_instance_of RMail::Message, decrypted[2]
+      assert_match(/^Signature made .* using RSA key ID 072B50BE/,
+                   decrypted[1].lines[0])
+      assert_equal "Good signature from \"#{@from_email}\"", decrypted[1].lines[1]
+      assert_equal "ABCDEFG" , decrypted[2].body
+    end
+
+    def test_decrypt_and_verify_nondefault_key
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      encrypted = CryptoManager.sign_and_encrypt @from_email_ecc, [@to_email], "ABCDEFG"
+      assert_instance_of RMail::Message, encrypted
+      assert_instance_of String, (encrypted.body[1].body)
+      decrypted = CryptoManager.decrypt encrypted.body[1], true
+      assert_instance_of Array, decrypted
+      assert_instance_of Chunk::CryptoNotice, decrypted[0]
+      assert_instance_of Chunk::CryptoNotice, decrypted[1]
+      assert_instance_of RMail::Message, decrypted[2]
+      assert_match(/^Signature made .* key ID AC34B83C/, decrypted[1].lines[0])
+      assert_equal "Good signature from \"#{@from_email_ecc}\"", decrypted[1].lines[1]
+      assert_equal "ABCDEFG" , decrypted[2].body
     end
 
     def test_verify
-        if CryptoManager.have_crypto?
-            signed = CryptoManager.sign @from_email, @to_email, "ABCDEFG"
-            assert_instance_of RMail::Message, signed
-            assert_instance_of String, (signed.body[1].body)
-            CryptoManager.verify signed.body[0], signed.body[1], true
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      signed = CryptoManager.sign @from_email, @to_email, "ABCDEFG"
+      assert_instance_of RMail::Message, signed
+      assert_instance_of String, (signed.body[1].body)
+      chunk = CryptoManager.verify signed.body[0], signed.body[1], true
+      assert_instance_of Redwood::Chunk::CryptoNotice, chunk
+      assert_match(/^Signature made .* using RSA key ID 072B50BE/,
+                   chunk.lines[0])
+      assert_equal "Good signature from \"#{@from_email}\"", chunk.lines[1]
     end
 
     def test_verify_unknown_keytype
-        if CryptoManager.have_crypto?
-            signed = CryptoManager.sign @from_email_ecc, @to_email, "ABCDEFG"
-            assert_instance_of RMail::Message, signed
-            assert_instance_of String, (signed.body[1].body)
-            CryptoManager.verify signed.body[0], signed.body[1], true
-        end
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      signed = CryptoManager.sign @from_email_ecc, @to_email, "ABCDEFG"
+      assert_instance_of RMail::Message, signed
+      assert_instance_of String, (signed.body[1].body)
+      chunk = CryptoManager.verify signed.body[0], signed.body[1], true
+      assert_instance_of Redwood::Chunk::CryptoNotice, chunk
+      assert_match(/^Signature made .* using unknown key type \(303\) key ID AC34B83C/,
+                   chunk.lines[0])
+      assert_equal "Good signature from \"#{@from_email_ecc}\"", chunk.lines[1]
     end
 
     def test_verify_nested_parts
-        if CryptoManager.have_crypto?
-            ## Generate a multipart/signed containing a multipart/mixed.
-            ## We will test verifying the generated signature below.
-            ## Importantly, the inner multipart/mixed does *not* have a
-            ## MIME-Version header because it is not a top-level message.
-            payload = RMail::Parser.read <<EOS
+      skip CryptoManager.not_working_reason if not CryptoManager.have_crypto?
+
+      ## Generate a multipart/signed containing a multipart/mixed.
+      ## We will test verifying the generated signature below.
+      ## Importantly, the inner multipart/mixed does *not* have a
+      ## MIME-Version header because it is not a top-level message.
+      payload = RMail::Parser.read <<EOS
 Content-Type: multipart/mixed; boundary="=-1652088224-7794-561531-1825-1-="
 
 
@@ -156,9 +199,8 @@ Content-Type: text/plain; name="attachment.txt"
 attachment
 --=-1652088224-7794-561531-1825-1-=--
 EOS
-            signed = CryptoManager.sign @from_email_ecc, @to_email, payload
-            CryptoManager.verify payload, signed.body[1], true
-        end
+      signed = CryptoManager.sign @from_email_ecc, @to_email, payload
+      CryptoManager.verify payload, signed.body[1], true
     end
 end
 

data/test/test_message.rb

@@ -253,6 +253,7 @@ class TestMessage < Minitest::Test
                  "bad: =?UTF16?q?badcharsetname?==?US-ASCII?b?/w?=" +
                  "=?UTF-7?Q?=41=6D=65=72=69=63=61=E2=80=99=73?=",
                  sup_message.subj)
+    assert_equal "=?utf-8?q?YouTube-tj=E4nst?=", sup_message.from.name
   end
 
   def test_nonascii_header
@@ -344,6 +345,35 @@ class TestMessage < Minitest::Test
     assert_equal("Second line.", chunks[2].lines[1])
   end
 
+  def test_embedded_message_rfc6532
+    source = DummySource.new("sup-test://test_embedded_message_rfc6532")
+    source.messages = [ fixture_path("embedded-message-rfc6532.eml") ]
+
+    sup_message = Message.build_from_source(source, 0)
+
+    chunks = sup_message.load_from_source!
+    assert_equal(3, chunks.length)
+
+    assert_equal("Email with embedded message", sup_message.subj)
+
+    assert(chunks[0].is_a? Redwood::Chunk::Text)
+    assert_equal("Example outer message.", chunks[0].lines[0])
+
+    assert(chunks[1].is_a? Redwood::Chunk::EnclosedMessage)
+    assert_equal(4, chunks[1].lines.length)
+    assert_equal("From: Embed sender <embed@example.com>", chunks[1].lines[0])
+    assert_equal("To: rcpt2 <rcpt2@example.invalid>", chunks[1].lines[1])
+    assert_equal("Date: ", chunks[1].lines[2][0..5])
+    assert_equal(
+      Time.rfc2822("Sun, 12 May 2024 17:34:29 +1000"),
+      Time.rfc2822(chunks[1].lines[2][6..-1])
+    )
+    assert_equal("Subject: Embedded subject line with emoji ✨", chunks[1].lines[3])
+
+    assert(chunks[2].is_a? Redwood::Chunk::Text)
+    assert_equal("Example embedded message, with UTF-8 headers.", chunks[2].lines[0])
+  end
+
   def test_malicious_attachment_names
     source = DummySource.new("sup-test://test_blank_header_lines")
     source.messages = [ fixture_path('malicious-attachment-names.eml') ]
@@ -359,6 +389,19 @@ class TestMessage < Minitest::Test
     fn = chunks[3].safe_filename
     assert_equal(fn, File.basename(fn))
   end
+
+  def test_invalid_date_header
+    fallback_date = Time.utc 2024, 5, 12, 15, 5, 56
+    source = DummySource.new("sup-test://test_invalid_date_header")
+    source.messages = [ fixture_path("invalid-date.eml") ]
+    source.fallback_date = fallback_date
+
+    sup_message = Message.build_from_source(source, 0)
+    sup_message.load_from_source!
+
+    assert_equal(fallback_date, sup_message.date)
+  end
+
   # TODO: test different error cases, malformed messages etc.
 
   # TODO: test different quoting styles, see that they are all divided

data/test/unit/test_contact.rb

@@ -1,4 +1,5 @@
 require 'test_helper'
+require 'sup'
 require 'sup/contact'
 
 module Redwood
@@ -6,7 +7,7 @@ module Redwood
 class TestContact < Minitest::Test
   def setup
     @contact = ContactManager.init(File.expand_path("../../fixtures/contacts.txt", __FILE__))
-    @person  = Person.new "Terrible Name", "terrible@name.com"
+    @person  = Person.new (+"Terrible Name"), (+"terrible@name.com")
   end
 
   def teardown
@@ -16,9 +17,20 @@ class TestContact < Minitest::Test
 
   def test_contact_manager
     assert @contact
-    ## 1 contact is imported from the fixture file.
-    assert_equal 1, @contact.contacts.count
-    assert_equal @contact.contact_for("RC").name, "Random Contact"
+
+    ## 2 contacts are imported from the fixture file.
+    assert_equal 2, @contact.contacts.count
+
+    rc = @contact.contact_for "RC"
+    assert_equal "Random Contact", rc.name
+    assert @contact.is_aliased_contact? rc
+    assert_equal "RC", @contact.alias_for(rc)
+
+    uc = @contact.person_for "unaliased@example.invalid"
+    refute @contact.is_aliased_contact? uc
+    assert_nil @contact.alias_for uc
+    assert_equal [rc, uc], @contact.contacts
+    assert_equal [rc], @contact.contacts_with_aliases
 
     assert_nil @contact.contact_for "TN"
     @contact.update_alias @person, "TN"

data/test/unit/test_edit_message_mode.rb

@@ -0,0 +1,99 @@
+require "test_helper"
+
+require "sup"
+
+class DummySelector
+  attr_accessor :val
+  def initialize val
+    @val = val
+  end
+end
+
+class DummyCryptoManager
+  def have_crypto?; true; end
+  def sign from, to, payload
+    envelope = RMail::Message.new
+    envelope.header["Content-Type"] = +"multipart/signed; protocol=testdummy"
+    envelope.add_part payload
+    envelope
+  end
+end
+
+class TestEditMessageMode < Minitest::Test
+  def setup
+    $config = {}
+    @path = Dir.mktmpdir
+    Redwood::HookManager.init File.join(@path, "hooks")
+    account = {
+      :name => +"test",
+      :email => +"sender@example.invalid",
+      :sendmail => "/bin/false",
+    }
+    Redwood::AccountManager.init :default => account
+    Redwood::CryptoManager.instance_variable_set :@instance, DummyCryptoManager.new
+  end
+
+  def teardown
+    Redwood::CryptoManager.deinstantiate!
+    Redwood::AccountManager.deinstantiate!
+    Redwood::HookManager.deinstantiate!
+    FileUtils.rm_r @path
+    $config = nil
+  end
+
+  def test_attachment_content_transfer_encoding
+    ## RMail::Message#make_attachment will choose
+    ## Content-Transfer-Encoding: 8bit for a CSV file.
+    ## If we're not GPG signing or encrypting then the attachment will be sent
+    ## as is. Note this assumes the SMTP servers in the delivery path all
+    ## support the 8BITMIME extension.
+    attachment_content = "löl,\ntest,\n"
+    attachment_filename = File.join @path, "dummy.csv"
+    File.write attachment_filename, attachment_content
+
+    opts = {
+      :header => {
+        "From" => +"sender@example.invalid",
+        "To" => +"recip@example.invalid",
+      },
+      :attachments => {
+        "dummy.csv" => RMail::Message.make_file_attachment(attachment_filename),
+      },
+    }
+    mode = Redwood::EditMessageMode.new opts
+
+    msg = mode.send :build_message, Time.now
+    attachment = msg.part(1)
+    assert_equal attachment_content, attachment.body
+    assert_equal "8bit", attachment.header["Content-Transfer-Encoding"]
+  end
+
+  def test_attachment_content_transfer_encoding_signed
+    attachment_filename = File.join @path, "dummy.csv"
+    ## Include some high bytes in the attachment contents in order to
+    ## exercise quote-printable transfer encoding.
+    File.write attachment_filename, "löl,\ntest,\n"
+
+    opts = {
+      :header => {
+        "From" => +"sender@example.invalid",
+        "To" => +"recip@example.invalid",
+      },
+      :attachments => {
+        "dummy.csv" => RMail::Message.make_file_attachment(attachment_filename),
+      },
+    }
+    mode = Redwood::EditMessageMode.new opts
+    mode.instance_variable_set :@crypto_selector, DummySelector.new(:sign)
+
+    msg = mode.send :build_message, Time.now
+    ## The outermost message is a (fake) multipart/signed created by DummyCryptoManager#send.
+    ## Inside that we have our inline message at index 0 and CSV attachment at index 1.
+    attachment = msg.part(0).part(1)
+    ## The attachment should have been re-encoded as quoted-printable for GPG signing.
+    assert_equal "l=C3=B6l,\ntest,\n", attachment.body
+    ## There shouldn't be multiple Content-Transfer-Encoding headers.
+    ## This was: https://github.com/sup-heliotrope/sup/issues/502
+    assert_equal ["quoted-printable"], attachment.header.fetch_all("Content-Transfer-Encoding")
+  end
+end

data/test/unit/test_index.rb

@@ -0,0 +1,65 @@
+require "minitest/mock"
+require "test_helper"
+
+require "sup"
+
+class TestIndex < Minitest::Test
+  def setup
+    @path = Dir.mktmpdir
+    Redwood::start
+    Redwood::Logger.remove_sink $stderr
+    Redwood::Index.init @path
+    Redwood::Index.load
+  end
+
+  def teardown
+    Redwood::Index.save_index
+    ObjectSpace.each_object(Class).select {|a| a < Redwood::Singleton}.each do |klass|
+      klass.deinstantiate! unless klass == Redwood::Logger
+    end
+    FileUtils.rm_r @path
+  end
+
+  def with_fake_time &block
+    Time.stub :now, Time.utc(2000) do
+      ## Also stub Time.local to behave like Time.utc so that Chronic.parse
+      ## doesn't pick up the timezone of the test runner.
+      Time.stub :local, ->(*args) { Time.utc(*args) }, &block
+    end
+  end
+
+  def test_date_query_parsing
+    parsed = with_fake_time do
+      Redwood::Index.parse_query "after:yesterday"
+    end
+    expected_qobj = Xapian::Query.new(
+      Xapian::Query::OP_VALUE_RANGE,
+      Redwood::Index::DATE_VALUENO,
+      Xapian.sortable_serialise(Time.utc(2000, 1, 1).to_i),
+      Xapian.sortable_serialise(2**32),
+    )
+    assert_equal expected_qobj.description, parsed[:qobj].description
+
+    parsed = with_fake_time do
+      Redwood::Index.parse_query "before:yesterday"
+    end
+    expected_qobj = Xapian::Query.new(
+      Xapian::Query::OP_VALUE_RANGE,
+      Redwood::Index::DATE_VALUENO,
+      Xapian.sortable_serialise(0),
+      Xapian.sortable_serialise(Time.utc(2000, 1, 1).to_i),
+    )
+    assert_equal expected_qobj.description, parsed[:qobj].description
+
+    parsed = with_fake_time do
+      Redwood::Index.parse_query "during:yesterday"
+    end
+    expected_qobj = Xapian::Query.new(
+      Xapian::Query::OP_VALUE_RANGE,
+      Redwood::Index::DATE_VALUENO,
+      Xapian.sortable_serialise(Time.utc(1999, 12, 31).to_i),
+      Xapian.sortable_serialise(Time.utc(2000,  1,  1).to_i),
+    )
+    assert_equal expected_qobj.description, parsed[:qobj].description
+  end
+end