[DRE-commits] [schleuder] 01/01: debian/patches: TMP! Add patch to debug gpg
Georg Faerber
georg-alioth-guest at moszumanska.debian.org
Sat Nov 25 16:13:55 UTC 2017
This is an automated email from the git hooks/post-receive script.
georg-alioth-guest pushed a commit to branch reproducible-builds-debug-gpg
in repository schleuder.
commit 036c94aff583dd27aa6b7a196a3f2864ad34babe
Author: Georg Faerber <georg at riseup.net>
Date: Sun Oct 1 14:19:47 2017 +0200
debian/patches: TMP! Add patch to debug gpg
---
debian/patches/gpg_debug | 3758 ++++++++++++++++++++++++++++++++++++++++++++++
debian/patches/series | 1 +
2 files changed, 3759 insertions(+)
diff --git a/debian/patches/gpg_debug b/debian/patches/gpg_debug
new file mode 100644
index 0000000..6fd7dba
--- /dev/null
+++ b/debian/patches/gpg_debug
@@ -0,0 +1,3758 @@
+--- a/spec/schleuder/unit/list_spec.rb
++++ b/spec/schleuder/unit/list_spec.rb
+@@ -1,461 +1,11 @@
+ require "spec_helper"
+
+ describe Schleuder::List do
+- BOOLEAN_LIST_ATTRIBUTES =
+- [
+- :send_encrypted_only, :receive_encrypted_only, :receive_signed_only,
+- :receive_authenticated_only, :receive_from_subscribed_emailaddresses_only,
+- :receive_admin_only, :keep_msgid, :bounces_drop_all,
+- :bounces_notify_admins, :include_list_headers, :include_list_headers,
+- :include_openpgp_header, :forward_all_incoming_to_admins
+- ].freeze
+-
+- it "has a valid factory" do
+- list = create(:list_with_one_subscription)
+-
+- expect(list).to be_valid
+- end
+-
+- it { is_expected.to respond_to :subscriptions }
+- it { is_expected.to respond_to :email }
+- it { is_expected.to respond_to :fingerprint }
+- it { is_expected.to respond_to :log_level }
+- it { is_expected.to respond_to :subject_prefix }
+- it { is_expected.to respond_to :subject_prefix_in }
+- it { is_expected.to respond_to :subject_prefix_out }
+- it { is_expected.to respond_to :openpgp_header_preference }
+- it { is_expected.to respond_to :public_footer }
+- it { is_expected.to respond_to :headers_to_meta }
+- it { is_expected.to respond_to :bounces_drop_on_headers }
+- it { is_expected.to respond_to :keywords_admin_only }
+- it { is_expected.to respond_to :keywords_admin_notify }
+- it { is_expected.to respond_to :send_encrypted_only }
+- it { is_expected.to respond_to :receive_encrypted_only }
+- it { is_expected.to respond_to :receive_signed_only }
+- it { is_expected.to respond_to :receive_authenticated_only }
+- it { is_expected.to respond_to :receive_from_subscribed_emailaddresses_only }
+- it { is_expected.to respond_to :receive_admin_only }
+- it { is_expected.to respond_to :keep_msgid }
+- it { is_expected.to respond_to :bounces_drop_all }
+- it { is_expected.to respond_to :bounces_notify_admins }
+- it { is_expected.to respond_to :include_list_headers }
+- it { is_expected.to respond_to :include_openpgp_header }
+- it { is_expected.to respond_to :max_message_size_kb }
+- it { is_expected.to respond_to :language }
+- it { is_expected.to respond_to :forward_all_incoming_to_admins }
+- it { is_expected.to respond_to :logfiles_to_keep }
+-
+- it "is invalid when email is nil" do
+- # Don't use factory here because we'd run into List.listdir expecting email to not be nil.
+- list = Schleuder::List.new(email: nil)
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:email]).to include("can't be blank")
+- end
+-
+- it "is invalid when email is blank" do
+- list = build(:list, email: "")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:email]).to include("can't be blank")
+- end
+-
+- it "is invalid when email does not contain an @" do
+- list = build(:list, email: "fooatbar.org")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:email]).to include("is not a valid email address")
+- end
+-
+- it "normalizes the fingerprint" do
+- fingerprint = " 99 991 1000 10"
+- list = build(:list, fingerprint: fingerprint)
+-
+- expect(list.fingerprint).to eq "99991100010"
+- end
+-
+- it "is invalid when fingerprint is blank" do
+- list = build(:list, fingerprint: "")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:fingerprint]).to include("can't be blank")
+- end
+-
+- it "is invalid when fingerprint is nil" do
+- list = build(:list, fingerprint: nil)
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:fingerprint]).to include("can't be blank")
+- end
+-
+- it "is invalid when fingerprint contains invalid characters" do
+- list = build(:list, fingerprint: "&$$$$67923AAA")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:fingerprint]).to include("is not a valid OpenPGP-fingerprint")
+- end
+-
+- BOOLEAN_LIST_ATTRIBUTES.each do |list_attribute|
+- it "is invalid if #{list_attribute} is nil" do
+- list = build(:list)
+- list[list_attribute] = nil
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[list_attribute]).to include("must be true or false")
+- end
+-
+- it "is invalid if #{list_attribute} is blank" do
+- list = build(:list)
+- list[list_attribute] = ""
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[list_attribute]).to include("must be true or false")
+- end
+- end
+-
+- [:headers_to_meta, :keywords_admin_only, :keywords_admin_notify].each do |list_attribute|
+- it "is invalid if #{list_attribute} contains special characters" do
+- list = build(:list)
+- list[list_attribute] =["$from", "to", "date", "cc"]
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[list_attribute]).to include("contains invalid characters")
+- end
+-
+- it "is valid if #{list_attribute} does not contain special characters" do
+- list = build(:list)
+- list[list_attribute] = ["foobar"]
+-
+- expect(list).to be_valid
+- end
+- end
+-
+- it "is invalid if bounces_drop_on_headers contains special characters" do
+- list = build(:list, bounces_drop_on_headers: {"$" => "%"})
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:bounces_drop_on_headers]).to include("contains invalid characters")
+- end
+-
+- [:subject_prefix, :subject_prefix_in, :subject_prefix_out].each do |list_attribute|
+- it "is invalid if #{list_attribute} contains a linebreak" do
+- list = build(:list)
+- list[list_attribute] = "Foo\nbar"
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[list_attribute]).to include("must not include line-breaks")
+- end
+-
+- it "is valid if #{list_attribute} is nil" do
+- list = build(:list)
+- list[list_attribute] = nil
+-
+- expect(list).to be_valid
+- end
+- end
+-
+- it "is invalid if openpgp_header_preference is foobar" do
+- list = build(:list, openpgp_header_preference: "foobar")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:openpgp_header_preference]).to include("must be one of: sign, encrypt, signencrypt, unprotected, none")
+- end
+-
+- [:max_message_size_kb, :logfiles_to_keep].each do |list_attribute|
+- it "is invalid if #{list_attribute} is 0" do
+- list = build(:list)
+- list[list_attribute] = 0
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[list_attribute]).to include("must be a number greater than zero")
+- end
+- end
+-
+- it "is invalid if log_level is foobar" do
+- list = build(:list, log_level: "foobar")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:log_level]).to include("must be one of: debug, info, warn, error")
+- end
+-
+- it "is invalid if language is jp" do
+- list = build(:list, language: "jp")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:language]).to include("must be one of: en, de")
+- end
+-
+- it "is invalid if public footer include a non-printable characters" do
+- list = build(:list, public_footer: "\a")
+-
+- expect(list).not_to be_valid
+- expect(list.errors.messages[:public_footer]).to include("includes non-printable characters")
+- end
+-
+- describe ".configurable_attributes" do
+- it "returns an array that contains the configurable attributes" do
+- expect(Schleuder::List.configurable_attributes).to eq [
+- :bounces_drop_all, :bounces_drop_on_headers, :bounces_notify_admins,
+- :forward_all_incoming_to_admins, :headers_to_meta, :include_list_headers,
+- :include_openpgp_header, :keep_msgid, :keywords_admin_notify, :keywords_admin_only,
+- :language, :log_level, :logfiles_to_keep, :max_message_size_kb, :openpgp_header_preference,
+- :public_footer, :receive_admin_only, :receive_authenticated_only, :receive_encrypted_only,
+- :receive_from_subscribed_emailaddresses_only, :receive_signed_only, :send_encrypted_only,
+- :subject_prefix, :subject_prefix_in, :subject_prefix_out,
+- ]
+- end
+-
+- it "does not contain the attributes email and fingerprint" do
+- expect(Schleuder::List.configurable_attributes).to_not include(:email)
+- expect(Schleuder::List.configurable_attributes).to_not include(:fingerprint)
+- end
+- end
+-
+- describe "#logfile" do
+- it "returns the logfile path" do
+- list = create(:list, email: "foo at bar.org")
+-
+- expect(list.logfile).to eq File.join(Schleuder::Conf.listlogs_dir, "bar.org/foo/list.log")
+- end
+- end
+-
+- describe "#logger" do
+- it "calls the ListLogger" do
+- list = create(:list)
+-
+- expect(Listlogger).to receive(:new).with(list)
+-
+- list.logger
+- end
+- end
+-
+- describe "#to_s" do
+- it "returns the email" do
+- list = create(:list, email: "foo at bar.org")
+-
+- expect(list.email).to eq "foo at bar.org"
+- end
+- end
+-
+- describe "#admins" do
+- it "returns subscriptions of admin users" do
+- list = create(:list)
+- admin_subscription = create(
+- :subscription,
+- email: "admin at foo.org",
+- admin: true,
+- list_id: list.id,
+- )
+- _user_subscription = create(
+- :subscription,
+- email: "user at foo.org",
+- admin: false,
+- list_id: list.id,
+- )
+-
+- expect(list.admins).to eq [admin_subscription]
+- end
+- end
+-
+- describe "#key" do
+- it "returns the key with the fingerprint of the list" do
+- list = create(
+- :list,
+- fingerprint: "59C7 1FB3 8AEE 22E0 91C7 8259 D063 5044 0F75 9BD3"
+- )
+-
+- expect(list.key.fingerprint()).to eq "59C71FB38AEE22E091C78259D06350440F759BD3"
+- end
+- end
+-
+- describe "#secret_key" do
+- it "returns the secret key with the fingerprint of the list" do
+- list = create(
+- :list,
+- fingerprint: "59C71FB38AEE22E091C78259D06350440F759BD3"
+- )
+-
+- expect(list.secret_key.secret?).to eq true
+- expect(list.secret_key.fingerprint).to eq "59C71FB38AEE22E091C78259D06350440F759BD3"
+- end
+- end
+-
+- describe "#keys" do
+- it "it returns an array with the keys of the list" do
+- list = create(:list)
+-
+- expect(list.keys).to be_kind_of Array
+- expect(list.keys.length).to eq 1
+- end
+-
+- it "returns an array of keys matching the given fingerprint" do
+- list = create(
+- :list,
+- fingerprint: "59C71FB38AEE22E091C78259D06350440F759BD3"
+- )
+-
+- expect(list.keys).to be_kind_of Array
+- expect(list.keys.first.fingerprint).to eq "59C71FB38AEE22E091C78259D06350440F759BD3"
+- end
+-
+- it "returns an array with the keys matching the given email address" do
+- list = create(:list, email: "schleuder at example.org")
+-
+- expect(list.keys("schleuder at example.org").length).to eq 1
+- expect(
+- list.keys("schleuder at example.org").first.fingerprint
+- ).to eq "59C71FB38AEE22E091C78259D06350440F759BD3"
+- end
+-
+- it "returns an array with the keys matching the given bracketed email address" do
+- list = create(:list, email: "schleuder at example.org")
+-
+- expect(
+- list.keys("bla <schleuder at example.org>").first.fingerprint
+- ).to eq "59C71FB38AEE22E091C78259D06350440F759BD3"
+- end
+- end
+-
+- describe "#import_key" do
+- it "imports a given key" do
+- list = create(:list)
+- key = File.read("spec/fixtures/example_key.txt")
+-
+- expect { list.import_key(key) }.to change { list.keys.count }.by(1)
+-
+- list.delete_key("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+- end
+- end
+-
+- describe "#delete_key" do
+- it "deletes the key with the given fingerprint" do
+- list = create(:list)
+- key = File.read("spec/fixtures/example_key.txt")
+- list.import_key(key)
+-
+- expect do
+- list.delete_key("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+- end.to change { list.keys.count }.by(-1)
+- end
+-
+- it "returns false if no key with the fingerprint was found" do
+- list = create(:list)
+-
+- expect(list.delete_key("A4C60C8833789C7CAA44496FD3FFA6611AB10CEC")).to eq false
+- end
+- end
+-
+- describe "#export_key" do
+- it "exports the key with the fingerprint of the list if no argument is given" do
+- list = create(:list, email: "schleuder at example.org")
+- expected_public_key = File.read("spec/fixtures/schleuder_at_example_public_key.txt")
+-
+- expect(list.export_key()).to include expected_public_key
+- end
+- end
+-
+- it "exports the key with the given fingerprint" do
+- list = create(:list, email: "schleuder at example.org")
+- expected_public_key = File.read("spec/fixtures/schleuder_at_example_public_key.txt")
+-
+- expect(
+- list.export_key("59C71FB38AEE22E091C78259D06350440F759BD3")
+- ).to include expected_public_key
+- end
+-
+- describe "#check_keys" do
+- it "adds a mesage if a key expires in two weeks or less" do
+- list = create(:list)
+- key = double("key")
+- allow_any_instance_of(GPGME::Key).to receive(:subkeys).and_return(key)
+- allow(key).to receive(:first).and_return(key)
+- allow(key).to receive(:expires).and_return(Time.now + 7.days)
+- allow(key).to receive(:fingerprint).and_return("59C71FB38AEE22E091C78259D06350440F759BD3")
+-
+- expect(list.check_keys).to eq "Key 59C71FB38AEE22E091C78259D06350440F759BD3 expires in 6 days.\n"
+- end
+-
+- it "adds a message if a key is revoked" do
+- list = create(:list)
+- allow_any_instance_of(GPGME::Key).to receive(:trust).and_return(:revoked)
+-
+- expect(list.check_keys).to eq "Key 59C71FB38AEE22E091C78259D06350440F759BD3 is revoked.\n"
+- end
+-
+- it "adds a message if a key is disabled" do
+- list = create(:list)
+- allow_any_instance_of(GPGME::Key).to receive(:trust).and_return(:disabled)
+-
+- expect(list.check_keys).to eq "Key 59C71FB38AEE22E091C78259D06350440F759BD3 is disabled.\n"
+- end
+-
+- it "adds a message if a key is invalid" do
+- list = create(:list)
+- allow_any_instance_of(GPGME::Key).to receive(:trust).and_return(:invalid)
+-
+- expect(list.check_keys).to eq "Key 59C71FB38AEE22E091C78259D06350440F759BD3 is invalid.\n"
+- end
+- end
+-
+- describe ".by_recipient" do
+- it "returns the list for a given address" do
+- list = create(:list, email: "list at example.org")
+-
+- expect(Schleuder::List.by_recipient("list-owner at example.org")).to eq list
+- end
+- end
+-
+- describe "#sendkey_address" do
+- it "adds the sendkey keyword to the email address" do
+- list = create(:list, email: "list at example.org")
+-
+- expect(list.sendkey_address).to eq "list-sendkey at example.org"
+- end
+- end
+-
+- describe "#request_address" do
+- it "adds the request keyword to the email address" do
+- list = create(:list, email: "list at example.org")
+-
+- expect(list.request_address).to eq "list-request at example.org"
+- end
+- end
+-
+- describe "#owner_address" do
+- it "adds the owner keyword to the email address" do
+- list = create(:list, email: "list at example.org")
+-
+- expect(list.owner_address).to eq "list-owner at example.org"
+- end
+- end
+-
+- describe "#bounce_address" do
+- it "adds the bounce keyword to the email address" do
+- list = create(:list, email: "list at example.org")
+-
+- expect(list.bounce_address).to eq "list-bounce at example.org"
+- end
+- end
+-
+- describe "#gpg" do
+- it "returns an instance of GPGME::Ctx" do
+- list = create(:list)
+-
+- expect(list.gpg).to be_an_instance_of GPGME::Ctx
+- end
+-
+- it "sets the GNUPGHOME environment variable to the listdir" do
+- list = create(:list)
+-
+- list.gpg
+-
+- expect(ENV["GNUPGHOME"]).to eq list.listdir
+- end
+- end
+-
+ context '#fetch_keys' do
+ it 'fetches one key by fingerprint' do
+ list = create(:list)
++ `echo "log-file /tmp/gpg.log\ndebug-level advanced" > #{list.listdir}/gpg.conf`
++ `echo "debug-level guru\nlog-file /tmp/dirmngr.log\ndebug 0xffffffff\nverbose" > #{list.listdir}/dirmngr.conf`
+ list.subscribe("admin at example.org", nil, true)
+ output = ''
+
+@@ -470,6 +20,8 @@
+
+ it 'fetches one key by URL' do
+ list = create(:list)
++ `echo "log-file /tmp/gpg.log\ndebug-level advanced" > #{list.listdir}/gpg.conf`
++ `echo "debug-level guru\nlog-file /tmp/dirmngr.log\ndebug 0xffffffff\nverbose" > #{list.listdir}/dirmngr.conf`
+ list.subscribe("admin at example.org", nil, true)
+ output = ''
+
+@@ -484,6 +36,8 @@
+
+ it 'fetches one key by email address' do
+ list = create(:list)
++ `echo "log-file /tmp/gpg.log\ndebug-level advanced" > #{list.listdir}/gpg.conf`
++ `echo "debug-level guru\nlog-file /tmp/dirmngr.log\ndebug 0xffffffff\nverbose" > #{list.listdir}/dirmngr.conf`
+ list.subscribe("admin at example.org", nil, true)
+ output = ''
+
+@@ -496,18 +50,4 @@
+ teardown_list_and_mailer(list)
+ end
+ end
+-
+- describe "send_list_key_to_subscriptions" do
+- it "sends its key to all subscriptions" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("admin at example.org", nil, true)
+- list.send_list_key_to_subscriptions
+-
+- raw = Mail::TestMailer.deliveries.first
+-
+- expect(raw.parts.first.parts.first.body.to_s).to eql("Find the key for this address attached.")
+- expect(raw.parts.first.parts.last.body.to_s).to include("4096R/59C71FB38AEE22E091C78259D06350440F759BD3")
+- expect(raw.parts.first.parts.last.body.to_s).to include("-----BEGIN PGP PUBLIC KEY BLOCK-----")
+- end
+- end
+ end
+--- a/spec/schleuder.yml
++++ b/spec/schleuder.yml
+@@ -1,7 +1,7 @@
+ database:
+ test:
+ adapter: sqlite3
+- database: db/test.sqlite3
++ database: /tmp/schleuder-test/test.sqlite3
+ lists_dir: /tmp/schleuder-test/
+ listlogs_dir: /tmp/schleuder-test/
+ smtp_settings:
+--- a/spec/schleuder/integration/cli_spec.rb
++++ b/spec/schleuder/integration/cli_spec.rb
+@@ -1,141 +1,10 @@
+ require "spec_helper"
+
+ describe 'cli' do
+- context "migrates a v2-list to v3.0" do
+- it 'creates the list' do
+- v2list_path = 'spec/fixtures/v2list'
+-
+- output = run_cli("migrate #{v2list_path}")
+- list = Schleuder::List.by_recipient('v2list at example.org')
+-
+- expect(output).to be_present
+- expect(list).to be_present
+- end
+-
+- it "imports the public keys" do
+- v2list_path = 'spec/fixtures/v2list'
+-
+- output = run_cli("migrate #{v2list_path}")
+- list = Schleuder::List.by_recipient('v2list at example.org')
+-
+- expect(output).not_to match('Error:')
+-
+- keys = list.keys.map(&:fingerprint)
+- expect(list.key.fingerprint).to eq '0392CF72B345256BB730049789226FD6A42B2A7A'
+- expect(keys).to include 'C4D60F8833789C7CAA44496FD3FFA6613AB10ECE'
+- end
+-
+- it "imports the secret key" do
+- v2list_path = 'spec/fixtures/v2list'
+-
+- output = run_cli("migrate #{v2list_path}")
+- list = Schleuder::List.by_recipient('v2list at example.org')
+-
+- expect(output).not_to match('Error:')
+-
+- expect(list.secret_key).to be_present
+- expect(list.secret_key.fingerprint).to eq '0392CF72B345256BB730049789226FD6A42B2A7A'
+-
+- signed = GPGME::Crypto.new(:armor => true).clearsign('lala').read
+-
+- expect(signed).to match(/^-----BEGIN PGP SIGNED MESSAGE-----\n.*\n\nlala\n-----BEGIN PGP SIGNATURE-----\n.*\n-----END PGP SIGNATURE-----\n$/m)
+- end
+-
+- it "imports the config" do
+- v2list_path = 'spec/fixtures/v2list'
+-
+- output = run_cli("migrate #{v2list_path}")
+- list = Schleuder::List.by_recipient('v2list at example.org')
+-
+- expect(output).not_to match('Error:')
+-
+- expect(list.to_s).to eq 'v2list at example.org'
+- expect(list.log_level).to eq 'warn'
+- expect(list.fingerprint).to eq '0392CF72B345256BB730049789226FD6A42B2A7A'
+- expect(list.keywords_admin_only).to eq %w[subscribe unsubscribe delete-key]
+- expect(list.keywords_admin_notify).to eq %w[add-key unsubscribe]
+- expect(list.send_encrypted_only).to eq false
+- expect(list.receive_encrypted_only).to eq false
+- expect(list.receive_signed_only).to eq false
+- expect(list.receive_authenticated_only).to eq false
+- expect(list.receive_from_subscribed_emailaddresses_only).to eq false
+- expect(list.receive_admin_only).to eq false
+- expect(list.keep_msgid).to eq true
+- expect(list.bounces_drop_all).to eq false
+- expect(list.bounces_notify_admins).to eq true
+- expect(list.include_list_headers).to eq true
+- expect(list.include_openpgp_header).to eq true
+- expect(list.openpgp_header_preference).to eq 'signencrypt'
+- expect(list.headers_to_meta).to eq %w[from to cc date]
+- expect(list.bounces_drop_on_headers).to eq({'x-spam-flag' => "yes"})
+- expect(list.subject_prefix).to eq '[v2]'
+- expect(list.subject_prefix_in).to eq '[in]'
+- expect(list.subject_prefix_out).to eq '[out]'
+- expect(list.max_message_size_kb).to eq 10240
+- expect(list.public_footer).to eq "-- \nfooter"
+- end
+-
+- it "imports the subscriptions" do
+- v2list_path = 'spec/fixtures/v2list'
+-
+- output = run_cli("migrate #{v2list_path}")
+- list = Schleuder::List.by_recipient('v2list at example.org')
+- admins_emails = list.admins.map(&:email)
+- subscription_emails = list.subscriptions.map(&:email)
+-
+- expect(output).not_to match('Error:')
+-
+- expect(admins_emails).to eql(["schleuder2 at example.org"])
+-
+- expect(subscription_emails).to eql(["anotherone at example.org", "anyone at example.org", "bla at foo", "old at example.org", "schleuder2 at example.org", "someone at example.org"])
+- expect(list.subscriptions.where(email: "anotherone at example.org").first.fingerprint).to eql('')
+- expect(list.subscriptions.where(email: "anyone at example.org").first.fingerprint).to eql("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+- expect(list.subscriptions.where(email: "bla at foo").first.fingerprint).to eql("87E65ED2081AE3D16BE4F0A5EBDBE899251F2412")
+- expect(list.subscriptions.where(email: "old at example.org").first.fingerprint).to eql("6EE51D78FD0B33DE65CCF69D2104E20E20889F66")
+- expect(list.subscriptions.where(email: "schleuder2 at example.org").first.fingerprint).to eql("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+- expect(list.subscriptions.where(email: "someone at example.org").first.fingerprint).to eql('')
+- end
+-
+- it "does not fail on duplicated v2 subscriptions" do
+- v2list_path = 'spec/fixtures/v2list_duplicate_members'
+-
+- output = run_cli("migrate #{v2list_path}")
+- expect(output).not_to match('Error:')
+- list = Schleuder::List.by_recipient('v2list at example.org')
+- subscription_emails = list.subscriptions.map(&:email)
+-
+- expect(subscription_emails).to eq ['schleuder2 at example.org']
+- end
+- it "respects non delivery status of admins" do
+- v2list_path = 'spec/fixtures/v2list_admin_non_delivery'
+-
+- output = run_cli("migrate #{v2list_path}")
+- expect(output).not_to match('Error:')
+- list = Schleuder::List.by_recipient('v2list at example.org')
+- subscriptions = list.subscriptions
+- expect(subscriptions.find{|s| s.email == 'schleuder2 at example.org' }.delivery_enabled).to eq false
+- subscription_emails = subscriptions.map(&:email)
+- expect(subscription_emails.sort).to eq(['schleuder2 at example.org',
+- 'schleuder2-member at example.org'].sort)
+- end
+- it "does not fail on admin without key" do
+- v2list_path = 'spec/fixtures/v2list_admin_without_key'
+-
+- output = run_cli("migrate #{v2list_path}")
+- expect(output).not_to match('Error:')
+-
+- list = Schleuder::List.by_recipient('v2list at example.org')
+- admin_emails = list.admins.map(&:email)
+-
+-
+- expect(admin_emails.sort).to eq( ['schleuder2 at example.org',
+- 'schleuder2-nokey at example.org' ].sort)
+- end
+- end
+-
+ context '#refresh_keys' do
+ it 'updates keys from the keyserver' do
+ list = create(:list)
++ `echo "debug-level guru\nlog-file /tmp/dirmngr.log\ndebug 0xffffffff\nverbose" > #{list.listdir}/dirmngr.conf`
+ list.subscribe("admin at example.org", nil, true)
+ list.import_key(File.read("spec/fixtures/expired_key.txt"))
+ list.import_key(File.read("spec/fixtures/olduid_key.txt"))
+@@ -153,6 +22,8 @@
+ it 'updates keys from the keyserver for only a specific list' do
+ list1 = create(:list)
+ list2 = create(:list)
++ `echo "debug-level guru\nlog-file /tmp/dirmngr.log\ndebug 0xffffffff\nverbose" > #{list1.listdir}/dirmngr.conf`
++ `echo "debug-level guru\nlog-file /tmp/dirmngr.log\ndebug 0xffffffff\nverbose" > #{list2.listdir}/dirmngr.conf`
+ [list1,list2].each do |list|
+ list.subscribe("admin at example.org", nil, true)
+ list.import_key(File.read("spec/fixtures/expired_key.txt"))
+@@ -170,84 +41,5 @@
+ teardown_list_and_mailer(list1)
+ teardown_list_and_mailer(list2)
+ end
+-
+- it 'reports errors from refreshing keys' do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- list.import_key(File.read("spec/fixtures/expired_key.txt"))
+-
+- Cli.new.refresh_keys
+- mail = Mail::TestMailer.deliveries.first
+-
+- expect(Mail::TestMailer.deliveries.length).to eq 1
+- expect(mail.to_s).to include("Refreshing all keys from the keyring of list #{list.email} resulted in this")
+- if GPGME::Ctx.sufficient_gpg_version?('2.1')
+- expect(mail.to_s).to include("keyserver refresh failed: No keyserver available")
+- else
+- # The wording differs slightly among versions.
+- expect(mail.to_s).to match(/gpgkeys: .* error .* connect/)
+- end
+-
+- teardown_list_and_mailer(list)
+- end
+- end
+- context '#pin_keys' do
+- it 'pins fingerprints on not yet set keys' do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- list.subscribe("schleuder2 at example.org", nil, false)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- expect(list.subscriptions_without_fingerprint.size).to eq 2
+-
+- Cli.new.pin_keys
+-
+- expect(list.subscriptions_without_fingerprint.size).to eq 1
+- expect(list.subscriptions_without_fingerprint.collect(&:email)).to eq ['admin at example.org']
+-
+- mail = Mail::TestMailer.deliveries.first
+-
+- expect(Mail::TestMailer.deliveries.length).to eq 1
+- expect(mail.first_plaintext_part.body.to_s).to eql("While checking all subscriptions of list #{list.email} we were pinning a matching key for the following subscriptions:\n\nschleuder2 at example.org: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+-
+- teardown_list_and_mailer(list)
+- end
+- it 'only works on the specific list' do
+- list1 = create(:list)
+- list2 = create(:list)
+- [list1,list2].each do |list|
+- list.subscribe("admin at example.org", nil, true)
+- list.subscribe("schleuder2 at example.org", nil, false)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- expect(list.subscriptions_without_fingerprint.size).to eq 2
+- end
+-
+- Cli.new.pin_keys list1.email
+-
+- expect(list1.subscriptions_without_fingerprint.size).to eq 1
+- expect(list1.subscriptions_without_fingerprint.collect(&:email)).to eq ['admin at example.org']
+- expect(list2.subscriptions_without_fingerprint.size).to eq 2
+-
+- mail = Mail::TestMailer.deliveries.first
+-
+- expect(Mail::TestMailer.deliveries.length).to eq 1
+- expect(mail.first_plaintext_part.body.to_s).to eql("While checking all subscriptions of list #{list1.email} we were pinning a matching key for the following subscriptions:\n\nschleuder2 at example.org: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+-
+- teardown_list_and_mailer(list1)
+- teardown_list_and_mailer(list2)
+- end
+-
+- it 'does not report anything if nothing was done' do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- list.subscribe("schleuder2 at example.org", nil, false)
+- expect(list.subscriptions_without_fingerprint.size).to eq 2
+-
+- Cli.new.pin_keys
+-
+- expect(list.subscriptions_without_fingerprint.size).to eq 2
+- expect(Mail::TestMailer.deliveries.empty?).to eq true
+-
+- teardown_list_and_mailer(list)
+- end
+ end
+ end
+--- a/spec/spec_helper.rb
++++ b/spec/spec_helper.rb
+@@ -61,10 +61,12 @@
+ end
+
+ def with_sks_mock
+- pid = Process.spawn('spec/sks-mock.rb', [:out, :err] => ["/tmp/sks-mock.log", 'w'])
+- sleep 1
++ sleep 5
++ current_time = (Time.now.to_f * 1000).to_i
++ pid = Process.spawn('spec/sks-mock.rb', [:out, :err] => ["/tmp/sks-mock-#{current_time}.log", 'w'])
++ sleep 5
+ yield
+- Process.kill 'TERM', pid
++ Process.kill 'INT', pid
+ Process.wait pid
+ end
+
+--- a/spec/schleuder/integration/dash_addresses_spec.rb
++++ /dev/null
+@@ -1,128 +0,0 @@
+-require "spec_helper"
+-
+-describe 'someone sends an email to a listname-dash-address' do
+- it "sends the list's key as reply to -sendkey" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", nil, true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.sendkey_address
+- mail.from = 'outside at example.org'
+- mail.body = 'The key, please!'
+- mail.subject = 'key'
+- mail.deliver
+-
+- mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- output = process_mail(mail.to_s, list.sendkey_address)
+- expect(output).to be_nil
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['outside at example.org'])
+- signed_message_parts = message.parts[0].parts
+- expect(signed_message_parts.first.body.to_s).to eql('Find the key for this address attached.')
+- expect(message.parts[0].attachments.first.body.to_s).to include(list.fingerprint)
+- expect(message.parts[0].attachments.first.body.to_s).to include('-----BEGIN PGP PUBLIC KEY BLOCK-----')
+- expect(message.in_reply_to).to eql(mail.message_id)
+- end
+-
+- it "forwards the message to the admins if extension is -owner" do
+- list = create(:list)
+- # owner needs a key so they get email
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.subscribe("admin at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.owner_address
+- mail.from = 'outside at example.org'
+- mail.body = 'Please contact me directly!'
+- mail.subject = 'help'
+- mail.deliver
+-
+- mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- output = process_mail(mail.to_s, list.owner_address)
+- expect(output).to be_nil
+-
+- raw_msgs = Mail::TestMailer.deliveries
+- raw_msgs.sort_by { |msg| msg.to.first }
+- # reparse the messages so we decrypt and remove all the craft
+- # for easier parsing afterwards
+- message1, message2 = raw_msgs[0..1].collect{|m|
+- Mail.create_message_to_list(m.to_s, list.email, list).setup
+- }
+-
+- expect(message1.to).to eql(['admin at example.org'])
+- expect(message1.subject).to eql('help')
+- expect(message1.parts.first.body.to_s).to include('From: outside at example.org')
+- expect(message1.parts.first.body.to_s).to include('Note: The following message was received for the list-owners.')
+- expect(message1.parts.last.body.to_s).to eql('Please contact me directly!')
+-
+- expect(message2.to).to eql(['schleuder at example.org'])
+- expect(message2.subject).to eql('help')
+- expect(message2.parts.first.body.to_s).to include('From: outside at example.org')
+- expect(message2.parts.first.body.to_s).to include('Note: The following message was received for the list-owners.')
+- expect(message2.parts.last.body.to_s).to eql('Please contact me directly!')
+- end
+-
+- it "forwards the message to the admins if extension is -bounce" do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.bounce_address
+- mail.from = 'mailer-daemon at example.org'
+- mail.body = 'delivery failure'
+- mail.subject = 'something'
+- mail.deliver
+-
+- mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- output = process_mail(mail.to_s, list.bounce_address)
+- expect(output).to be_nil
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['admin at example.org'])
+- expect(message.subject).to eql(I18n.t('automated_message_subject'))
+- signed_message_parts = message.parts[0].parts
+- expect(signed_message_parts.first.body.to_s).to eql(I18n.t('forward_automated_message_to_admins'))
+- expect(signed_message_parts.last.mime_type).to eql('message/rfc822')
+- expect(signed_message_parts.last.body.to_s).to include('From: mailer-daemon at example.org')
+- expect(signed_message_parts.last.body.to_s).to include(mail.message_id)
+- expect(signed_message_parts.last.body.to_s).to include("Subject: something")
+- expect(signed_message_parts.last.body.to_s).to include("delivery failure")
+- end
+-
+- it "forwards the message to the admins if extension is -bounce and it's a real bounce mail" do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new(File.read('spec/fixtures/mails/bounce.eml'))
+- mail.to = list.owner_address
+- mail.deliver
+-
+- mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- output = process_mail(mail.to_s, list.bounce_address)
+- expect(output).to be_nil
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['admin at example.org'])
+- expect(message.subject).to eql(I18n.t('automated_message_subject'))
+- signed_message_parts = message.parts[0].parts
+- expect(signed_message_parts.first.body.to_s).to eql(I18n.t('forward_automated_message_to_admins'))
+- expect(signed_message_parts.last.mime_type).to eql('message/rfc822')
+- expect(signed_message_parts.last.body.to_s).to include('Mailer-Daemon at schleuder.example.org')
+- expect(signed_message_parts.last.body.to_s).to include(mail.message_id)
+- expect(signed_message_parts.last.body.to_s).to include("Subject: bounce test")
+- expect(signed_message_parts.last.body.to_s).to include("mailbox is full")
+- end
+-end
+-
+--- a/spec/schleuder/integration/filters_spec.rb
++++ /dev/null
+@@ -1,157 +0,0 @@
+-require "spec_helper"
+-
+-describe "running filters" do
+- context '.max_message_size' do
+- it "bounces to big mails" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = '+' * (1024 * list.max_message_size_kb)
+- mail.deliver
+-
+- big_email = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- output = process_mail(big_email.to_s, list.email)
+- expect(output.message).to eql(I18n.t('errors.message_too_big', { allowed_size: list.max_message_size_kb }))
+-
+- teardown_list_and_mailer(list)
+- end
+- end
+- context '.fix_hotmail_messages!' do
+- it "accepts an invalid pgp/mime hotmail message" do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- # so we can easily parse the outgoing mail
+- list.send_encrypted_only = false
+- list.save
+-
+- start_smtp_daemon
+- message_path = 'spec/fixtures/mails/hotmail.eml'
+-
+- error = run_schleuder(:work, list.email, message_path)
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- hotmail = Mail.read(mails.first)
+-
+- expect(hotmail.to).to eql(["admin at example.org"])
+- expect(hotmail.body.to_s).to include("foo\n")
+-
+- stop_smtp_daemon
+- end
+- it "accepts a valid plain-text message" do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- # so we can easily parse the outgoing mail
+- list.send_encrypted_only = false
+- list.save
+-
+- start_smtp_daemon
+- message_path = 'spec/fixtures/mails/hotmail_no_parts.eml'
+-
+- error = run_schleuder(:work, list.email, message_path)
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- hotmail = Mail.read(mails.first)
+-
+- expect(hotmail.to).to eql(["admin at example.org"])
+- expect(hotmail.body.to_s).to include("bla-vla")
+-
+- stop_smtp_daemon
+- end
+- end
+-
+- context '.strip_html_from_alternative!' do
+- it "strips HTML-part from multipart/alternative-message that contains ascii-armored PGP-data" do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- # so we can easily parse the outgoing mail
+- list.send_encrypted_only = false
+- list.save
+-
+- start_smtp_daemon
+-
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = 'outside at example.org'
+- content = encrypt_string(list, "blabla")
+- mail.text_part = content
+- mail.html_part = "<p>#{content}</p>"
+- mail.subject = "test"
+-
+- error = nil
+- with_tmpfile(mail.to_s) do |fn|
+- error = run_schleuder(:work, list.email, fn)
+- end
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- htmlmail = Mail.read(mails.first)
+-
+- expect(htmlmail.to).to eql(["admin at example.org"])
+- signed_parts = htmlmail.parts[0].parts
+- expect(signed_parts[0].body.to_s).to include("Note: This message included an alternating HTML-part that contained PGP-data. The HTML-part was removed to enable parsing the message more properly.")
+- # why is this double wrapped?
+- expect(signed_parts[1].parts[0][:content_type].content_type).to eql("text/plain")
+- expect(signed_parts[1].parts[0].body.to_s).to eql("blabla\n")
+-
+- stop_smtp_daemon
+- end
+- it "does NOT strip HTML-part from multipart/alternative-message that does NOT contain ascii-armored PGP-data" do
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- # so we can easily parse the outgoing mail
+- list.send_encrypted_only = false
+- list.save
+-
+- start_smtp_daemon
+-
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = 'outside at example.org'
+- content = "blabla"
+- mail.text_part = content
+- mail.html_part = "<p>#{content}</p>"
+- mail.subject = "test"
+-
+- error = nil
+- with_tmpfile(mail.to_s) do |fn|
+- error = run_schleuder(:work, list.email, fn)
+- end
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- htmlmail = Mail.read(mails.first)
+-
+- expect(htmlmail.to).to eql(["admin at example.org"])
+- # this is double wrapped
+- signed_parts = htmlmail.parts[0].parts[1].parts
+- expect(signed_parts[0][:content_type].content_type).to eql("text/plain")
+- expect(signed_parts[0].body.to_s).to eql("blabla")
+- expect(signed_parts[1][:content_type].content_type).to eql("text/html")
+- expect(signed_parts[1].body.to_s).to eql("<p>blabla</p>")
+-
+- stop_smtp_daemon
+- end
+- end
+-end
+--- a/spec/schleuder/integration/keywords_spec.rb
++++ /dev/null
+@@ -1,1743 +0,0 @@
+-require "spec_helper"
+-
+-describe "user sends keyword" do
+- it "x-subscribe without attributes" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-SUBSCRIBE: test at example.org"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("test at example.org has been subscribed")
+- expect(message.to_s).to match(/Fingerprint:\s*$/)
+- expect(message.to_s).to include("Admin? false")
+- expect(message.to_s).to include("Email-delivery enabled? true")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to be_blank
+- expect(subscription.admin).to eql(false)
+- expect(subscription.delivery_enabled).to eql(true)
+-
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-subscribe with attributes" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-SUBSCRIBE: test at example.org 0x#{list.fingerprint} true false"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("test at example.org has been subscribed")
+- expect(message.to_s).to match(/Fingerprint:\s+#{list.fingerprint.downcase}/)
+- expect(message.to_s).to include("Admin? true")
+- expect(message.to_s).to include("Email-delivery enabled? false")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql(list.fingerprint.downcase)
+- expect(subscription.admin).to eql(true)
+- expect(subscription.delivery_enabled).to eql(false)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-subscribe with attributes and spaces-separated fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-SUBSCRIBE: test at example.org 0x#{list.fingerprint.dup.insert(4, ' ')} true false"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("test at example.org has been subscribed")
+- expect(message.to_s).to match(/Fingerprint:\s+#{list.fingerprint.downcase}/)
+- expect(message.to_s).to include("Admin? true")
+- expect(message.to_s).to include("Email-delivery enabled? false")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql(list.fingerprint.downcase)
+- expect(subscription.admin).to eql(true)
+- expect(subscription.delivery_enabled).to eql(false)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-unsubscribe without argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- list.subscribe("admin at example.org", 'C4D60F8833789C7CAA44496FD3FFA6613AB10ECE', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = 'schleuder at example.org'
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: '59C71FB38AEE22E091C78259D06350440F759BD3'
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-UNSUBSCRIBE:"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("schleuder at example.org has been unsubscribed")
+-
+- expect(subscription).to be_blank
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-unsubscribe with invalid argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-UNSUBSCRIBE: test at example.org"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("test at example.org is not subscribed")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-unsubscribe" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.subscribe("test at example.org")
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-UNSUBSCRIBE: test at example.org"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("test at example.org has been unsubscribed")
+-
+- expect(subscription).to be_blank
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-set-fingerprint with own email-address and valid fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: schleuder at example.org C4D60F8833789C7CAA44496FD3FFA6613AB10ECE"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'schleuder at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Fingerprint for schleuder at example.org set to c4d60f8833789c7caa44496fd3ffa6613ab10ece")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql('c4d60f8833789c7caa44496fd3ffa6613ab10ece')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+-
+- it "x-set-fingerprint with own email-address and valid, spaces-separated fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: schleuder at example.org C4D6 0F88 3378 9C7C AA44 496F D3FF A661 3AB1 0ECE"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'schleuder at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Fingerprint for schleuder at example.org set to c4d60f8833789c7caa44496fd3ffa6613ab10ece")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql('c4d60f8833789c7caa44496fd3ffa6613ab10ece')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+-
+- it "x-set-fingerprint without email-address and with valid fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'schleuder at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Fingerprint for schleuder at example.org set to c4d60f8833789c7caa44496fd3ffa6613ab10ece")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql('c4d60f8833789c7caa44496fd3ffa6613ab10ece')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-set-fingerprint with other email-address and valid fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.subscribe('test at example.org')
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: test at example.org C4D60F8833789C7CAA44496FD3FFA6613AB10ECE"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Fingerprint for test at example.org set to c4d60f8833789c7caa44496fd3ffa6613ab10ece")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql('c4d60f8833789c7caa44496fd3ffa6613ab10ece')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-set-fingerprint with other email-address and valid fingerprint as non-admin" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3')
+- list.subscribe("test at example.org", 'C4D60F8833789C7CAA44496FD3FFA6613AB10ECE', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = 'schleuder at example.org'
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: '59C71FB38AEE22E091C78259D06350440F759BD3'
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: test at example.org 59C71FB38AEE22E091C78259D06350440F759BD3"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'test at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Only admins may set fingerprints of subscriptions other than their own")
+-
+- expect(subscription).to be_present
+- expect(subscription.fingerprint).to eql('C4D60F8833789C7CAA44496FD3FFA6613AB10ECE')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-set-fingerprint without email-address and with invalid fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: blabla"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- subscription = list.subscriptions.where(email: 'schleuder at example.org').first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Fingerprint is not a valid OpenPGP-fingerprint")
+-
+- expect(subscription.fingerprint).to eql('59C71FB38AEE22E091C78259D06350440F759BD3')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-set-fingerprint with not-subscribed email-address and valid fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-set-fingerprint: bla at example.org C4D60F8833789C7CAA44496FD3FFA6613AB10ECE"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("bla at example.org is not subscribed")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-subscriptions without arguments" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-subscriptions:"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.first_plaintext_part.body.to_s.lines.size).to eql(3)
+- expect(message.to_s).to include("schleuder at example.org 0x59C71FB38AEE22E091C78259D06350440F759BD3")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-subscriptions without arguments but with admin-notification" do
+- list = create(:list, keywords_admin_notify: ['list-subscriptions'])
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.subscribe("user at example.org")
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-subscriptions:"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- notification = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- raw = Mail::TestMailer.deliveries[1]
+- response = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+- expected_text = "Subscriptions:\n\nschleuder at example.org\t0x59C71FB38AEE22E091C78259D06350440F759BD3\nuser at example.org"
+-
+- expect(Mail::TestMailer.deliveries.size).to eql(2)
+- expect(notification.to).to eql(['schleuder at example.org'])
+- expect(notification.first_plaintext_part.body.to_s).to eql("schleuder at example.org sent the keyword 'list-subscriptions' and received this response:\n\n#{expected_text}")
+-
+- expect(response.to).to eql(['schleuder at example.org'])
+- expect(response.first_plaintext_part.body.to_s).to eql(expected_text)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-subscriptions with matching argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-subscriptions: example.org"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.first_plaintext_part.body.to_s.lines.size).to eql(3)
+- expect(message.to_s).to include("schleuder at example.org 0x59C71FB38AEE22E091C78259D06350440F759BD3")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-subscriptions with non-matching argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-subscriptions: blabla"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.first_plaintext_part.body.to_s.lines.size).to eql(1)
+- expect(message.to_s).to include("Your message resulted in no output")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-add-key with inline key-material" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- keymaterial = File.read('spec/fixtures/example_key.txt')
+- mail.body = "x-listname: #{list.email}\nX-ADD-KEY:\n#{keymaterial}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE: imported")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-add-key with attached key-material" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-ADD-KEY:"
+- mail.add_file('spec/fixtures/example_key.txt')
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("C4D60F8833789C7CAA44496FD3FFA6613AB10ECE: imported")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with invalid input" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: lala!"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Invalid input.")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with email address" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: admin at example.org"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Key 98769E8A1091F36BD88403ECF71A3F8412D83889 was fetched (new key)")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with unknown email-address" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: something at localhost"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Fetching something at localhost did not succeed")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with URL" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: http://127.0.0.1:9999/keys/example.asc"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Key 98769E8A1091F36BD88403ECF71A3F8412D83889 was fetched (new key)")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with invalid URL" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- url = "http://127.0.0.1:9999/foo"
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: #{url}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Fetching #{url} did not succeed")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with unknown fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: 0x0000000000000000000000000000000000000000"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Fetching 0x0000000000000000000000000000000000000000 did not succeed")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: 0x98769E8A1091F36BD88403ECF71A3F8412D83889"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to_s).to include("Key 98769E8A1091F36BD88403ECF71A3F8412D83889 was fetched (new key)")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-fetch-key with fingerprint of unchanged key" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-fetch-KEY: 0x59C71FB38AEE22E091C78259D06350440F759BD3"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- with_sks_mock do
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.first_plaintext_part.body.to_s).to eql("Key 59C71FB38AEE22E091C78259D06350440F759BD3 was fetched (unchanged).")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-resend" do
+- list = create(:list, public_footer: "-- \nblablabla")
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "Hello again!\n"
+- mail.body = "x-listname: #{list.email}\nX-resend: someone at example.org\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- resent_message = raw.verify
+- resent_message_body = resent_message.parts.map { |p| p.body.to_s }.join
+- raw = Mail::TestMailer.deliveries.last
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Resent: Unencrypted to someone at example.org")
+- expect(resent_message.to).to include("someone at example.org")
+- expect(resent_message.to_s).not_to include("Resent: Unencrypted to someone at example.org")
+- expect(resent_message_body).to eql(content_body + list.public_footer.to_s)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-resend with admin-notification" do
+- list = create(:list, keywords_admin_notify: ['resend'])
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "Hello again!\n"
+- mail.body = "x-listname: #{list.email}\nX-resend: someone at example.org\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries[1]
+- notification = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+- raw = Mail::TestMailer.deliveries[2]
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(Mail::TestMailer.deliveries.size).to eql(3)
+-
+- expect(notification.to).to eql(['schleuder at example.org'])
+- expect(notification.first_plaintext_part.body.to_s).to eql("schleuder at example.org used the keyword 'resend' with the values 'someone at example.org' in a message sent to the list.")
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Resent: Unencrypted to someone at example.org")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-resend without x-listname" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "Hello again!\n"
+- mail.body = "X-resend: someone at example.org\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).not_to include("Resent: Unencrypted to someone at example.org")
+- expect(message.to_s).to include("Your message didn't contain the mandatory X-LISTNAME-keyword, thus it was rejected.")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-resend with two matching keys, one of which is expired" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- list.import_key(File.read("spec/fixtures/expired_key.txt"))
+- list.import_key(File.read("spec/fixtures/bla_foo_key.txt"))
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "Hello again!\n"
+- mail.body = "x-listname: #{list.email}\nX-resend-encrypted-only: bla at foo\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- resent_message = Mail::TestMailer.deliveries.first
+- raw = Mail::TestMailer.deliveries.last
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(list.keys('bla at foo').size).to eql(2)
+- expect(resent_message.to).to eql(['bla at foo'])
+- expect(resent_message.content_type).to match(/^multipart\/encrypted.*application\/pgp-encrypted/)
+- expect(message.first_plaintext_part.body.to_s).to include("Resent: Encrypted to bla at foo (87E65ED2081AE3D16BE4F0A5EBDBE899251F2412)")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-resend with expired key" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- list.import_key(File.read("spec/fixtures/expired_key.txt"))
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "Hello again!\n"
+- mail.body = "x-listname: #{list.email}\nX-resend-encrypted-only: bla at foo\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(list.keys('bla at foo').size).to eql(1)
+- expect(message.first_plaintext_part.to_s).to include("Resending to <bla at foo> failed (0 keys found")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-resend with wrong x-listname" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "Hello again!\n"
+- mail.body = "x-listname: somethingelse at example.org\nX-resend: someone at example.org\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).not_to include("Resent: Unencrypted to someone at example.org")
+- expect(message.to_s).to include("Your message contained a wrong X-LISTNAME-keyword. The value of that keyword must match the email address of this list.")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-sign-this with inline text" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- signed_text = "signed\nsigned\nsigned\n\n"
+- mail.body = "x-listname: #{list.email}\nx-sign-this:\n#{signed_text}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(message.to_s.gsub("\r", '')).to include("BEGIN PGP SIGNED MESSAGE-----\n\n#{signed_text}-----END PGP SIGNED MESSAGE")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-sign-this with attachments" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- keywords = Mail::Part.new
+- keywords.body = "\n\nx-listname: #{list.email}\nx-sign-this:"
+- mail.parts << keywords
+- signed_content = File.read('spec/fixtures/example_key.txt')
+- mail.attachments['example_key.txt'] = { mime_type: 'application/pgp-key',
+- content: signed_content }
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+- signature = message.attachments.first.body.to_s
+- # list.gpg.verify() results in a "Bad Signature". The sign-this plugin
+- # also uses GPGME::Crypto, apparently that makes a difference.
+- crypto = GPGME::Crypto.new
+- verification_string = ''
+- crypto.verify(signature, {signed_text: signed_content}) do |sig|
+- verification_string = sig.to_s
+- end
+-
+- expect(message.to_s).to include("Find the signatures attached.")
+- expect(message.attachments.size).to eql(1)
+- expect(message.attachments.first.filename).to eql("example_key.txt.sig")
+- expect(verification_string).to include("Good signature from D06350440F759BD3")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-key with arbitrary email-sub-string" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-KEYs: der at ex"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("pub 4096R/59C71FB38AEE22E091C78259D06350440F759BD3 2016-12-06")
+- expect(message.to_s.scan(/^pub /).size).to eql(1)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-key with correctly prefixed email-sub-string" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-KEYs: @schleuder"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("pub 4096R/59C71FB38AEE22E091C78259D06350440F759BD3 2016-12-06")
+- expect(message.to_s.scan(/^pub /).size).to eql(1)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-list-key with prefixed fingerprint" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-list-KEYs: 0x59C71FB38AEE22E091C78259D06350440F759BD3"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("pub 4096R/59C71FB38AEE22E091C78259D06350440F759BD3 2016-12-06")
+- expect(message.to_s.scan(/^pub /).size).to eql(1)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+-
+- it "x-get-key with valid argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-GET-KEY: 0x59C71FB38AEE22E091C78259D06350440F759BD3"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("pub 4096R/59C71FB38AEE22E091C78259D06350440F759BD3 2016-12-06")
+- expect(message.to_s).to include("-----BEGIN PGP PUBLIC KEY")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-get-key with invalid argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-get-KEY: blabla"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("No match found for")
+- expect(message.to_s).not_to include("-----BEGIN PGP PUBLIC KEY")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-get-key with empty argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-get-KEY:"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Your message resulted in no output")
+- expect(message.to_s).not_to include("-----BEGIN PGP PUBLIC KEY")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-delete-key with valid argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-delete-KEY: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Deleted: C4D60F8833789C7CAA44496FD3FFA6613AB10ECE")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-delete-key with invalid argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-delete-KEY: lala"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("No match found for")
+- expect(message.to_s).not_to include("Deleted")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-delete-key with not distinctly matching argument" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- list.import_key(File.read('spec/fixtures/example_key.txt'))
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-delete-KEY: schleuder"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.to_s).to include("Too many matching keys for ")
+- expect(message.to_s).not_to include("Deleted")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-get-logfile with debug level sends non-empty logfile" do
+- list = create(:list)
+- list.update_attribute(:log_level, 'debug')
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-get-logfile"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.parts.last.body.to_s.lines.size).to be > 1
+- expect(message.parts.last.body.to_s).to include("Logfile created on")
+- expect(message.parts.last.body.to_s).to include("DEBUG")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-get-logfile with error-level sends empty logfile" do
+- list = create(:list)
+- list.update_attribute(:log_level, 'error')
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-get-logfile"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.first_plaintext_part.body.to_s.lines.size).to eql(1)
+- expect(message.body.to_s).to include("Logfile created on")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-attach-listkey" do
+- list = create(:list, log_level: 'debug')
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.email => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- content_body = "something something list-key"
+- mail.body = "x-listname: #{list.email}\nX-attach-listkey\n#{content_body}"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.email)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.email, list).setup
+-
+- expect(message.parts.length).to eql(2)
+- expect(message.parts.last.parts.length).to eql(2)
+- expect(message.parts.last.parts.first.body.to_s).to eql(content_body)
+- expect(message.parts.last.parts.last.content_type.to_s).to eql("application/pgp-keys")
+- expect(message.parts.last.parts.last.body.decoded).to include("pub 4096R/59C71FB38AEE22E091C78259D06350440F759BD3 2016-12-06")
+- expect(message.parts.last.parts.last.body.decoded).to include("-----BEGIN PGP PUBLIC KEY BLOCK-----")
+- expect(message.parts.last.parts.last.body.decoded).to include("mQINBFhGvz0BEADXbbTWo/PStyTznAo/f1UobY0EiVPNKNERvYua2Pnq8BwOQ5bS")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "x-get-version" do
+- list = create(:list)
+- list.subscribe("schleuder at example.org", '59C71FB38AEE22E091C78259D06350440F759BD3', true)
+- ENV['GNUPGHOME'] = list.listdir
+- mail = Mail.new
+- mail.to = list.request_address
+- mail.from = list.admins.first.email
+- gpg_opts = {
+- encrypt: true,
+- keys: {list.request_address => list.fingerprint},
+- sign: true,
+- sign_as: list.admins.first.fingerprint
+- }
+- mail.gpg(gpg_opts)
+- mail.body = "x-listname: #{list.email}\nX-get-version"
+- mail.deliver
+-
+- encrypted_mail = Mail::TestMailer.deliveries.first
+- Mail::TestMailer.deliveries.clear
+-
+- begin
+- Schleuder::Runner.new().run(encrypted_mail.to_s, list.request_address)
+- rescue SystemExit
+- end
+- raw = Mail::TestMailer.deliveries.first
+- message = Mail.create_message_to_list(raw.to_s, list.request_address, list).setup
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.first_plaintext_part.body.to_s.lines.size).to eql(1)
+- expect(message.first_plaintext_part.body.to_s).to eql(Schleuder::VERSION)
+-
+- teardown_list_and_mailer(list)
+- end
+-
+-end
+--- a/spec/schleuder/integration/receive_bounce.rb
++++ /dev/null
+@@ -1,19 +0,0 @@
+-require "spec_helper"
+-
+-describe "a bounce message is received" do
+- it "from bounce example" do
+- start_smtp_daemon
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- message_path = 'spec/fixtures/mails/bounce.eml'
+-
+- error = run_schleuder(:work, list.email, message_path)
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- stop_smtp_daemon
+- end
+-end
+-
+--- a/spec/schleuder/integration/send_encrypted_spec.rb
++++ /dev/null
+@@ -1,19 +0,0 @@
+-require "spec_helper"
+-
+-describe "user sends an encrypted message" do
+- it "from thunderbird" do
+- start_smtp_daemon
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- message_path = 'spec/fixtures/mails/encrypted-mime/thunderbird.eml'
+-
+- error = run_schleuder(:work, list.email, message_path)
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- stop_smtp_daemon
+- end
+-end
+-
+--- a/spec/schleuder/integration/send_plain_spec.rb
++++ /dev/null
+@@ -1,19 +0,0 @@
+-require "spec_helper"
+-
+-describe "user sends a plain text message" do
+- it "from thunderbird" do
+- start_smtp_daemon
+- list = create(:list)
+- list.subscribe("admin at example.org", nil, true)
+- message_path = 'spec/fixtures/mails/plain/thunderbird.eml'
+-
+- error = run_schleuder(:work, list.email, message_path)
+- mails = Dir.glob("#{smtp_daemon_outputdir}/mail-*")
+-
+- expect(error).to be_empty
+- expect(mails.size).to eq 1
+-
+- stop_smtp_daemon
+- end
+-end
+-
+--- a/spec/schleuder/runner_spec.rb
++++ /dev/null
+@@ -1,210 +0,0 @@
+-require "spec_helper"
+-
+-describe Schleuder::Runner do
+- describe "#run" do
+- context "with a plain text message" do
+- it "delivers the incoming message" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- error = Schleuder::Runner.new().run(mail, list.email)
+-
+- expect(Mail::TestMailer.deliveries.length).to eq 1
+- expect(error).to be_blank
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "has the correct headerlines" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eq ["admin at example.org"]
+- expect(message.header.to_s.scan("admin at example.org").size).to eq 1
+- expect(message.from).to eq [list.email]
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "doesn't have unwanted headerlines from the original message" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eq ["admin at example.org"]
+- expect(message.header.to_s.scan("zeromail").size).to eq 0
+- expect(message.header.to_s.scan("nna.local").size).to eq 0
+- expect(message.header.to_s.scan("80.187.107.60").size).to eq 0
+- expect(message.header.to_s.scan("User-Agent:").size).to eq 0
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "doesn't leak the Message-Id as configured" do
+- list = create(:list, send_encrypted_only: false, keep_msgid: false)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.header.to_s.scan("8db04406-e2ab-fd06-d4c5-c19b5765c52b at web.de").size).to eq 0
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "does keep the Message-Id as configured" do
+- list = create(:list, send_encrypted_only: false, keep_msgid: true)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.header.to_s.scan("8db04406-e2ab-fd06-d4c5-c19b5765c52b at web.de").size).to eq 1
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "contains the list headers if include_list_headers is set to true" do
+- list = create(
+- :list,
+- email: "superlist at example.org",
+- send_encrypted_only: false,
+- include_list_headers: true,
+- )
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.header["List-Id"].to_s).to eq "<superlist.example.org>"
+- expect(message.header["List-Owner"].to_s).to eq "<mailto:superlist-owner at example.org> (Use list's public key)"
+- expect(message.header["List-Help"].to_s).to eq "<https://schleuder.nadir.org/>"
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "contains the open pgp header if include_openpgp_header is set to true" do
+- list = create(
+- :list,
+- send_encrypted_only: false,
+- include_openpgp_header: true,
+- )
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.header["Openpgp"].to_s).to include list.fingerprint
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "does not deliver content if send_encrypted_only is set to true" do
+- list = create(:list, send_encrypted_only: true)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.body).to eq ""
+- expect(message.parts.first.body.to_s).to include "You missed an email from "\
+- "#{list.email} because your subscription isn't associated with a "\
+- "(usable) OpenPGP key. Please fix this."
+-
+- teardown_list_and_mailer(list)
+- end
+- end
+-
+- it "delivers a signed error message if a subscription's key is expired on a encrypted-only list" do
+- list = create(:list, send_encrypted_only: true)
+- list.subscribe("admin at example.org", nil, true, false)
+- list.subscribe("expired at example.org", '98769E8A1091F36BD88403ECF71A3F8412D83889')
+- key = File.read("spec/fixtures/expired_key.txt")
+- list.import_key(key)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+- verified = message.verify
+- signature_fingerprints = verified.signatures.map(&:fpr)
+-
+- expect(Mail::TestMailer.deliveries.size).to eq 1
+- expect(message.to).to include('expired at example.org')
+- expect(message.to_s).to include("You missed an email from ")
+- expect(signature_fingerprints).to eq([list.fingerprint])
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "delivers a signed error message if a subscription's key is not available on a encrypted-only list" do
+- list = create(:list, send_encrypted_only: true)
+- list.subscribe("admin at example.org", 'AAAAAAAABBBBBBBBBCCCCCCCCCDDDDDDDDEEEEEE', true)
+- mail = File.read("spec/fixtures/mails/plain/thunderbird.eml")
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eq ['admin at example.org']
+- expect(message.to_s).to include("You missed an email from #{list.email} ")
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "injects pseudoheaders appropriately into an unsigned thunderbird-multipart/alternative-message" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read('spec/fixtures/mails/multipart-alternative/thunderbird-multi-alt-unsigned.eml')
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+- content_part = message.parts.first
+-
+- expect(message.to).to eq ['admin at example.org']
+- expect(content_part.mime_type).to eql('multipart/mixed')
+- expect(content_part.body).to be_blank
+- expect(content_part.parts.size).to eql(2)
+- expect(content_part.parts.first.mime_type).to eql('text/plain')
+- expect(content_part.parts.first.body).to include('From: paz <paz at nadir.org>')
+- expect(content_part.parts.last.mime_type).to eql('multipart/alternative')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+- it "injects pseudoheaders appropriately into a signed multipart/alternative-message (thunderbird+enigmail-1.9) " do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("admin at example.org", nil, true)
+- mail = File.read('spec/fixtures/mails/multipart-alternative/thunderbird-multi-alt-signed.eml')
+-
+- Schleuder::Runner.new().run(mail, list.email)
+- message = Mail::TestMailer.deliveries.first
+- content_part = message.parts.first
+-
+- expect(message.to).to eq ['admin at example.org']
+- expect(content_part.mime_type).to eql('multipart/mixed')
+- expect(content_part.body).to be_blank
+- expect(content_part.parts.size).to eql(2)
+- expect(content_part.parts.first.mime_type).to eql('text/plain')
+- expect(content_part.parts.first.body).to include('From: paz <paz at nadir.org>')
+- expect(content_part.parts.last.mime_type).to eql('multipart/mixed')
+- expect(content_part.parts.last.parts.size).to eql(1)
+- expect(content_part.parts.last.parts.first.mime_type).to eql('multipart/alternative')
+-
+- teardown_list_and_mailer(list)
+- end
+-
+-
+- end
+-end
+--- a/spec/schleuder/unit/filters_runner_spec.rb
++++ /dev/null
+@@ -1,57 +0,0 @@
+-require "spec_helper"
+-
+-module Schleuder::Filters
+- def self.dummy(list,mail)
+- nil
+- end
+- def self.stop(list,mail)
+- nil
+- end
+-end
+-
+-describe Schleuder::Filters::Runner do
+- let(:subject) do
+- # setup the list with an admin that can be notified
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- Schleuder::Filters::Runner.new(list)
+- end
+-
+- it { is_expected.to respond_to :run }
+-
+- context '#run' do
+- it 'runs the filters' do
+- mail = Mail.new
+- expect(Schleuder::Filters).to receive(:dummy).once
+- expect(Schleuder::Filters).to_not receive(:stop)
+- expect(subject.run(mail,['dummy'])).to be_nil
+- end
+-
+- it 'stops on a StandardError and returns error' do
+- mail = Mail.new
+- error = StandardError.new
+- expect(Schleuder::Filters).to_not receive(:dummy)
+- expect(Schleuder::Filters).to receive(:stop).once { error }
+- expect(subject.run(mail,['stop','dummy'])).to eql(error)
+- expect(Mail::TestMailer.deliveries.first).to be_nil
+- end
+- it 'stops on a StandardError and will notify admins' do
+- mail = Mail.new
+- error = StandardError.new
+- subject.list.bounces_drop_all = true
+- expect(Schleuder::Filters).to_not receive(:dummy)
+- expect(Schleuder::Filters).to receive(:stop).once { error }
+- expect(subject.run(mail,['stop','dummy'])).to be_nil
+- expect(Mail::TestMailer.deliveries.first).to_not be_nil
+- end
+- it 'stops on a StandardError and will notify on headers match' do
+- mail = Mail.new
+- error = StandardError.new
+- mail['X-SPAM-FLAG'] = 'TRUE'
+- expect(Schleuder::Filters).to_not receive(:dummy)
+- expect(Schleuder::Filters).to receive(:stop).once { error }
+- expect(subject.run(mail,['stop','dummy'])).to be_nil
+- expect(Mail::TestMailer.deliveries.first).to_not be_nil
+- end
+- end
+-end
+--- a/spec/schleuder/unit/filters_spec.rb
++++ /dev/null
+@@ -1,72 +0,0 @@
+-require "spec_helper"
+-
+-describe Schleuder::Filters do
+-
+- context '.fix_hostmail_messages!' do
+- it "fixes pgp/mime-messages that were mangled by hotmail" do
+- message = Mail.read("spec/fixtures/mails/hotmail.eml")
+- Schleuder::Filters.fix_hotmail_messages!(nil, message)
+-
+- expect(message[:content_type].content_type).to eql("multipart/encrypted")
+- end
+- it "works with a text/plain message" do
+- message = Mail.read("spec/fixtures/mails/hotmail_no_parts.eml")
+- Schleuder::Filters.fix_hotmail_messages!(nil, message)
+-
+- expect(message[:content_type].content_type).to eql("text/plain")
+- end
+- end
+-
+- context '.strip_html_from_alternative!' do
+- it "strips HTML-part from multipart/alternative-message that contains ascii-armored PGP-data" do
+- list = create(:list)
+- mail = Mail.new
+- mail.to = list.email
+- mail.from = 'outside at example.org'
+- content = encrypt_string(list, "blabla")
+- mail.text_part = content
+- mail.html_part = "<p>#{content}</p>"
+- mail.subject = "test"
+-
+- Schleuder::Filters.strip_html_from_alternative!(list, mail)
+-
+- expect(mail[:content_type].content_type).to eql("multipart/mixed")
+- expect(mail.parts.size).to be(1)
+- expect(mail.parts.first[:content_type].content_type).to eql("text/plain")
+- expect(mail.dynamic_pseudoheaders).to include("Note: This message included an alternating HTML-part that contained PGP-data. The HTML-part was removed to enable parsing the message more properly.")
+- end
+-
+- it "does NOT strip HTML-part from multipart/alternative-message that does NOT contain ascii-armored PGP-data" do
+- mail = Mail.new
+- mail.to = 'schleuder at example.org'
+- mail.from = 'outside at example.org'
+- content = "blabla"
+- mail.text_part = content
+- mail.html_part = "<p>#{content}</p>"
+- mail.subject = "test"
+-
+- Schleuder::Filters.strip_html_from_alternative!(nil, mail)
+-
+- expect(mail[:content_type].content_type).to eql("multipart/alternative")
+- expect(mail.parts.size).to be(2)
+- expect(mail.parts.first[:content_type].content_type).to eql("text/plain")
+- expect(mail.parts.last[:content_type].content_type).to eql("text/html")
+- expect(mail.dynamic_pseudoheaders).not_to include("Note: This message included an alternating HTML-part that contained PGP-data. The HTML-part was removed to enable parsing the message more properly.")
+- end
+-
+- it "does not choke on nor change a message without Content-Type-header" do
+- mail = Mail.new
+- mail.to = 'schleuder at example.org'
+- mail.from = 'outside at example.org'
+- mail.body = "blabla"
+- mail.subject = "test"
+-
+- Schleuder::Filters.strip_html_from_alternative!(nil, mail)
+-
+- expect(mail[:content_type]).to be_nil
+- expect(mail.parts.size).to be(0)
+- expect(mail.dynamic_pseudoheaders).not_to include("Note: This message included an alternating HTML-part that contained PGP-data. The HTML-part was removed to enable parsing the message more properly.")
+- end
+- end
+-
+-end
+--- a/spec/schleuder/unit/gpgme_ctx.rb
++++ /dev/null
+@@ -1,171 +0,0 @@
+-require "spec_helper"
+-
+-describe GPGME::Ctx do
+- it "#keyimport" do
+- list = create(:list)
+- keymaterial = File.read('spec/fixtures/example_key.txt')
+-
+- expect(list.gpg.keys.map(&:fingerprint)).not_to include('C4D60F8833789C7CAA44496FD3FFA6613AB10ECE')
+- expect {
+- list.gpg.keyimport(keymaterial)
+- }.to change{ list.gpg.keys.size }.by 1
+- expect(list.gpg.keys.map(&:fingerprint)).to include('C4D60F8833789C7CAA44496FD3FFA6613AB10ECE')
+- end
+-
+- it "#keyimport with unusable data" do
+- list = create(:list)
+- keymaterial = "blabla"
+-
+- expect(list.gpg.keys.map(&:fingerprint)).not_to include('C4D60F8833789C7CAA44496FD3FFA6613AB10ECE')
+- expect {
+- list.gpg.keyimport(keymaterial)
+- }.to change{ list.gpg.keys.size }.by 0
+- expect(list.gpg.keys.map(&:fingerprint)).not_to include('C4D60F8833789C7CAA44496FD3FFA6613AB10ECE')
+- end
+-
+- it "#find_keys with prefixed fingerprint" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('0x59C71FB38AEE22E091C78259D06350440F759BD3')
+-
+- expect(keys.size).to eql(1)
+- end
+-
+- it "#find_keys with un-prefixed fingerprint" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('59C71FB38AEE22E091C78259D06350440F759BD3')
+-
+- expect(keys.size).to eql(1)
+- end
+-
+- it "#find_keys with bracketed email-address" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('schleuder <schleuder at example.org>')
+-
+- expect(keys.size).to eql(1)
+- end
+-
+- it "#find_keys with bracketed wrong email-address" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('blabla <blabla at example.org>')
+-
+- expect(keys.size).to eql(0)
+- end
+-
+- it "#find_keys with un-bracketed email-address" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('schleuder at example.org')
+-
+- expect(keys.size).to eql(1)
+- end
+-
+- it "#find_keys with un-bracketed wrong email-address" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('blabla at example.org')
+-
+- expect(keys.size).to eql(0)
+- end
+-
+- it "#find_keys with correctly marked sub-string" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('@schleuder')
+-
+- expect(keys.size).to eql(2)
+- end
+-
+- it "#find_keys with correctly marked narrower sub-string" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('@schleuder@')
+-
+- expect(keys.size).to eql(1)
+- end
+-
+- it "#find_keys with un-marked sub-string" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys('schleuder')
+-
+- expect(keys.size).to eql(2)
+- end
+-
+- it "#find_keys without argument" do
+- list = create(:list)
+- list.import_key(File.read("spec/fixtures/example_key.txt"))
+- keys = list.gpg.find_keys()
+-
+- expect(keys.size).to eql(2)
+- end
+-
+- it "#clean_and_classify_input with prefixed fingerprint" do
+- list = create(:list)
+-
+- kind, input = list.gpg.clean_and_classify_input('0x59C71FB38AEE22E091C78259D06350440F759BD3')
+- expect(kind).to eql(:fingerprint)
+- expect(input).to eql('0x59C71FB38AEE22E091C78259D06350440F759BD3')
+- end
+-
+- it "#clean_and_classify_input with un-prefixed fingerprint" do
+- list = create(:list)
+-
+- kind, input = list.gpg.clean_and_classify_input('59C71FB38AEE22E091C78259D06350440F759BD3')
+- expect(kind).to eql(:fingerprint)
+- expect(input).to eql('0x59C71FB38AEE22E091C78259D06350440F759BD3')
+- end
+-
+- it "#clean_and_classify_input with bracketed email-address" do
+- list = create(:list)
+-
+- kind, input = list.gpg.clean_and_classify_input('bla <bla at foo>')
+- expect(kind).to eql(:email)
+- expect(input).to eql('<bla at foo>')
+- end
+-
+- it "#clean_and_classify_input with un-bracketed email-address" do
+- list = create(:list)
+-
+- kind, input = list.gpg.clean_and_classify_input('bla at foo')
+- expect(kind).to eql(:email)
+- expect(input).to eql('<bla at foo>')
+- end
+-
+- it "#clean_and_classify_input with URL" do
+- list = create(:list)
+-
+- kind, input = list.gpg.clean_and_classify_input('http://example.org/foo')
+- expect(kind).to eql(:url)
+- expect(input).to eql('http://example.org/foo')
+- end
+-
+- it "#clean_and_classify_input with some string" do
+- list = create(:list)
+-
+- kind, input = list.gpg.clean_and_classify_input('lala')
+- expect(kind).to eql(nil)
+- expect(input).to eql('lala')
+- end
+-
+- it "#gpgcli returns correct data types" do
+- list = create(:list)
+-
+- err, out, exitcode = list.gpg.class.gpgcli('--list-keys')
+- expect(err.class).to eql(Array)
+- expect(out.class).to eql(Array)
+- expect(exitcode.class).to eql(Integer)
+- end
+-
+- it "#gpgcli_expect returns correct data types" do
+- list = create(:list)
+-
+- err, out, exitcode = list.gpg.class.gpgcli_expect('--list-keys') { nil }
+- expect(err.class).to eql(Array)
+- expect(out.class).to eql(NilClass)
+- expect(exitcode.class).to eql(Integer)
+- end
+-end
+--- a/spec/schleuder/unit/list_builder_spec.rb
++++ /dev/null
+@@ -1,55 +0,0 @@
+-require "spec_helper"
+-
+-describe Schleuder::ListBuilder do
+-
+- it "creates a new, valid list" do
+- listname = "list-#{rand}@example.org"
+- adminaddress = 'schleuder2 at example.org'
+- adminkey = File.read('spec/fixtures/example_key.txt')
+- list, messages = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run
+- expect(list).to be_an_instance_of Schleuder::List
+- expect(list).to be_valid
+- expect(messages).to be_blank
+- end
+-
+- it "returns an error-message if given an invalid email-address" do
+- listname = "list-#{rand}"
+- adminaddress = 'schleuder2 at example.org'
+- adminkey = File.read('spec/fixtures/example_key.txt')
+- list, messages = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run
+- expect(list).to be_nil
+- expect(messages).to be_an_instance_of Hash
+- expect(messages.keys).to eq ['email']
+- expect(messages.values).to be_present
+- end
+-
+- it "creates a listdir for the list" do
+- listname = "list-#{rand}@example.org"
+- adminaddress = 'schleuder2 at example.org'
+- adminkey = File.read('spec/fixtures/example_key.txt')
+- list, _ = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run
+- expect(File.directory?(list.listdir)).to be true
+- end
+-
+- it "creates a list-key with all required UIDs" do
+- listname = "list-#{rand}@example.org"
+- adminaddress = 'schleuder2 at example.org'
+- adminkey = File.read('spec/fixtures/example_key.txt')
+- list, _ = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run
+- uids = list.key.uids.map(&:email)
+- expect(uids).to include(list.email)
+- expect(uids).to include(list.request_address)
+- expect(uids).to include(list.owner_address)
+- end
+-
+- it "subscribes the adminaddress and imports the adminkey" do
+- listname = "list-#{rand}@example.org"
+- adminaddress = 'schleuder2 at example.org'
+- adminkey = File.read('spec/fixtures/example_key.txt')
+- list, _ = ListBuilder.new({email: listname, fingerprint: nil}, adminaddress, adminkey).run
+- subscription_emails = list.subscriptions.map(&:email)
+- keys_emails = list.keys.map(&:uids).flatten.map(&:email)
+- expect(subscription_emails).to eq [adminaddress]
+- expect(keys_emails).to include(adminaddress)
+- end
+-end
+--- a/spec/schleuder/unit/logger_notifications_spec.rb
++++ /dev/null
+@@ -1,84 +0,0 @@
+-require "spec_helper"
+-
+-describe Schleuder::LoggerNotifications do
+- context 'return path' do
+- it 'sets default superadmin' do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- list.logger.notify_admin("Something", nil, I18n.t('notice'))
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.sender).to eql('root at localhost')
+- expect(message[:Errors_To].to_s).to eql('root at localhost')
+- end
+-
+- it 'sets superadmin' do
+- oldval = Conf.instance.config['superadmin']
+- Conf.instance.config['superadmin'] = 'schleuder-admin at example.org'
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- list.logger.notify_admin("Something", nil, I18n.t('notice'))
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.sender).to eql('schleuder-admin at example.org')
+- expect(message[:Errors_To].to_s).to eql('schleuder-admin at example.org')
+- Conf.instance.config['superadmin'] = oldval
+- end
+- end
+- it "notifies admins of simple text-message" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- list.logger.notify_admin("Something", nil, I18n.t('notice'))
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.subject).to eql(I18n.t('notice'))
+- expect(message.first_plaintext_part.body.to_s).to eql("Something")
+- end
+-
+- it "notifies admins of multiple text-messages" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- list.logger.notify_admin(["Something", "anotherthing"], nil, I18n.t('notice'))
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.subject).to eql(I18n.t('notice'))
+- expect(message.parts.first.parts.first.body.to_s).to eql("Something")
+- expect(message.parts.first.parts.last.body.to_s).to eql("anotherthing")
+- end
+-
+- it "notifies admins of multiple text-messages" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- list.logger.notify_admin(["Something", "anotherthing"], nil, I18n.t('notice'))
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.subject).to eql(I18n.t('notice'))
+- expect(message.parts.first.parts.first.body.to_s).to eql("Something")
+- expect(message.parts.first.parts.last.body.to_s).to eql("anotherthing")
+- end
+-
+- it "notifies admins of multiple text-messages and the original message" do
+- list = create(:list, send_encrypted_only: false)
+- list.subscribe("schleuder at example.org", nil, true)
+- mail = Mail.new
+- mail.subject = "A subject"
+- list.logger.notify_admin(["Something", "anotherthing"], mail.to_s, I18n.t('notice'))
+-
+- message = Mail::TestMailer.deliveries.first
+-
+- expect(message.to).to eql(['schleuder at example.org'])
+- expect(message.subject).to eql(I18n.t('notice'))
+- expect(message.parts.first.parts.first.body.to_s).to eql("Something")
+- expect(message.parts.first.parts[1].body.to_s).to eql("anotherthing")
+- expect(message.parts.first.parts[2].body.to_s).to include("Subject: A subject")
+- expect(message.parts.first.parts[2][:content_type].content_type).to eql("message/rfc822")
+- end
+-end
+--- a/spec/schleuder/unit/message_spec.rb
++++ /dev/null
+@@ -1,104 +0,0 @@
+-require "spec_helper"
+-
+-describe Mail::Message do
+- it "doesn't change the order of mime-parts" do
+- text_part = Mail::Part.new
+- text_part.body = "This is text"
+- image_part = Mail::Part.new
+- image_part.content_type = 'image/png'
+- image_part.content_disposition = 'attachment; filename=spec.png'
+- message = Mail.new
+- message.parts << image_part
+- message.parts << text_part
+-
+- # This triggers the sorting.
+- message.to_s
+-
+- expect(message.parts.first.mime_type).to eql('image/png')
+- expect(message.parts.last.mime_type).to eql('text/plain')
+- end
+-
+- # TODO: test message with "null" address ("<>") as Return-Path. I couldn't
+- # bring Mail to generate such a message, yet.
+-
+- it "recognizes a message sent to listname-bounce at hostname as automated message" do
+- list = create(:list)
+- mail = Mail.new
+- # Trigger the setting of mandatory headers.
+- mail.to_s
+- mail = Mail.create_message_to_list(mail.to_s, 'something-bounce at localhost', list).setup
+-
+- expect(mail.automated_message?).to be(true)
+- end
+-
+- it "recognizes a message with 'Auto-Submitted'-header as automated message" do
+- list = create(:list)
+- mail = Mail.new
+- mail.header['Auto-Submitted'] = 'yes'
+- # Trigger the setting of mandatory headers.
+- mail.to_s
+- mail = Mail.create_message_to_list(mail.to_s, 'something at localhost', list).setup
+-
+- expect(mail.automated_message?).to be(true)
+- end
+-
+- it "recognizes a cron message with 'Auto-Submitted'-header NOT as automated message" do
+- list = create(:list)
+- mail = Mail.new
+- mail.header['Auto-Submitted'] = 'yes'
+- mail.header['X-Cron-Env'] = '<MAILTO=root>'
+- # Trigger the setting of mandatory headers.
+- mail.to_s
+- mail = Mail.create_message_to_list(mail.to_s, 'something at localhost', list).setup
+-
+- expect(mail.automated_message?).to be(false)
+- end
+-
+- context '#add_subject_prefix!' do
+- it 'adds a configured subject prefix' do
+- list = create(:list)
+- list.subject_prefix = '[prefix]'
+- list.subscribe('admin at example.org',nil,true)
+- mail = Mail.new
+- mail.from 'someone at example.org'
+- mail.to list.email
+- mail.text_part = 'blabla'
+- mail.subject = 'test'
+-
+- message = Mail.create_message_to_list(mail.to_s, list.email, list).setup
+- message.add_subject_prefix!
+-
+- expect(message.subject).to eql('[prefix] test')
+- end
+- it 'adds a configured subject prefix without subject' do
+- list = create(:list)
+- list.subject_prefix = '[prefix]'
+- list.subscribe('admin at example.org',nil,true)
+- mail = Mail.new
+- mail.from 'someone at example.org'
+- mail.to list.email
+- mail.text_part = 'blabla'
+-
+- message = Mail.create_message_to_list(mail.to_s, list.email, list).setup
+- message.add_subject_prefix!
+-
+- expect(message.subject).to eql('[prefix]')
+- end
+- it 'does not add a subject prefix if already present' do
+- list = create(:list)
+- list.subject_prefix = '[prefix]'
+- list.subscribe('admin at example.org',nil,true)
+- mail = Mail.new
+- mail.from 'someone at example.org'
+- mail.to list.email
+- mail.text_part = 'blabla'
+- mail.subject = 'Re: [prefix] test'
+-
+- message = Mail.create_message_to_list(mail.to_s, list.email, list).setup
+- message.add_subject_prefix!
+-
+- expect(message.subject).to eql('Re: [prefix] test')
+- end
+- end
+-end
+-
+--- a/spec/schleuder/unit/subscription_spec.rb
++++ /dev/null
+@@ -1,107 +0,0 @@
+-require "spec_helper"
+-
+-describe Schleuder::Subscription do
+- BOOLEAN_SUBSCRIPTION_ATTRIBUTES =
+- [
+- :delivery_enabled,
+- :admin
+- ].freeze
+-
+- it "has a valid factory" do
+- subscription = create(:subscription)
+-
+- expect(subscription).to be_valid
+- end
+-
+- it { is_expected.to respond_to :list_id }
+- it { is_expected.to respond_to :email }
+- it { is_expected.to respond_to :fingerprint }
+- it { is_expected.to respond_to :admin }
+- it { is_expected.to respond_to :delivery_enabled }
+-
+- it "is invalid when list_id is blank" do
+- subscription = build(:subscription, list_id: "")
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[:list_id]).to be_present
+- end
+-
+- it "is invalid when email is nil" do
+- subscription = build(:subscription, email: nil)
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[:email]).to include("can't be blank")
+- end
+-
+- it "is invalid when email is blank" do
+- subscription = build(:subscription, email: "")
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[:email]).to include("can't be blank")
+- end
+-
+- it "is invalid when email does not contain an @" do
+- subscription = build(:subscription, email: "fooatbar.org")
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[:email]).to include("is not a valid email address")
+- end
+-
+- it "normalizes the fingerprint" do
+- fingerprint = "0x 99 991 1000 10"
+- subscription = build(:subscription, fingerprint: fingerprint)
+-
+- expect(subscription.fingerprint).to eq "99991100010"
+- end
+-
+- it "is valid when fingerprint is empty" do
+- subscription = build(:subscription, fingerprint: "")
+-
+- expect(subscription).to be_valid
+- expect(subscription.errors.messages[:fingerprint]).to be_blank
+- end
+-
+- it "is valid when fingerprint is nil" do
+- subscription = build(:subscription, fingerprint: nil)
+-
+- expect(subscription).to be_valid
+- expect(subscription.errors.messages[:fingerprint]).to be_blank
+- end
+-
+- it "is invalid when fingerprint contains invalid characters" do
+- subscription = build(:subscription, fingerprint: "&$$$$123AAA")
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[:fingerprint]).to include("is not a valid OpenPGP-fingerprint")
+- end
+-
+- BOOLEAN_SUBSCRIPTION_ATTRIBUTES.each do |subscription_attribute|
+- it "is invalid if #{subscription_attribute} is nil" do
+- subscription = build(:subscription)
+- subscription[subscription_attribute] = nil
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[subscription_attribute]).to include("must be true or false")
+- end
+-
+- it "is invalid if #{subscription_attribute} is blank" do
+- subscription = build(:subscription)
+- subscription[subscription_attribute] = ""
+-
+- expect(subscription).not_to be_valid
+- expect(subscription.errors.messages[subscription_attribute]).to include("must be true or false")
+- end
+- end
+-
+- it "is invalid if the given email is already subscribed for the list" do
+- subscription1 = create(:subscription)
+- subscription2 = build(:subscription, email: subscription1.email)
+- subscription3 = build(:subscription, email: subscription1.email, list_id: subscription1.list_id)
+-
+- expect(subscription1).to be_valid
+- expect(subscription2).to be_valid
+- expect(subscription3).not_to be_valid
+- expect(subscription3.errors[:email]).to eql(["is already subscribed"])
+- end
+-end
+-
diff --git a/debian/patches/series b/debian/patches/series
index 364ec50..b0fc43f 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,3 +1,4 @@
+gpg_debug
0005-man-fix-log-path.patch
0001-lib-fix-paths.patch
0004-spec-remove-bundler.patch
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-ruby-extras/schleuder.git
More information about the Pkg-ruby-extras-commits
mailing list