imap-backup 6.0.0.rc2 → 6.0.0

data/spec/features/restore_spec.rb

@@ -1,162 +0,0 @@
-require "features/helper"
-
-RSpec.describe "restore", type: :aruba, docker: true do
-  include_context "imap-backup connection"
-  include_context "message-fixtures"
-
-  let(:local_backup_path) { File.expand_path("~/backup") }
-  let(:folder) { "my-stuff" }
-  let(:messages_as_mbox) do
-    message_as_mbox_entry(msg1) + message_as_mbox_entry(msg2)
-  end
-  let(:messages_as_server_messages) do
-    [message_as_server_message(msg1), message_as_server_message(msg2)]
-  end
-  let(:message_uids) { [msg1[:uid], msg2[:uid]] }
-  let(:existing_imap_content) { imap_data(uid_validity, message_uids).to_json }
-  let(:uid_validity) { 1234 }
-
-  let!(:pre) {}
-  let!(:setup) do
-    create_directory local_backup_path
-    File.write(imap_path(folder), existing_imap_content)
-    File.write(mbox_path(folder), messages_as_mbox)
-    create_config(accounts: [account.to_h])
-
-    run_command_and_stop("imap-backup restore #{account.username}")
-  end
-  let(:cleanup) do
-    server_delete_folder folder
-  end
-
-  after { cleanup }
-
-  context "when the folder doesn't exist" do
-    it "restores messages" do
-      messages = server_messages(folder).map { |m| server_message_to_body(m) }
-      expect(messages).to eq(messages_as_server_messages)
-    end
-
-    it "updates local uids to match the new server ones" do
-      updated_imap_content = imap_parsed(folder)
-      expect(server_uids(folder)).to eq(updated_imap_content[:uids])
-    end
-
-    it "sets the backup uid_validity to match the new folder" do
-      updated_imap_content = imap_parsed(folder)
-      expect(updated_imap_content[:uid_validity]).
-        to eq(server_uid_validity(folder))
-    end
-  end
-
-  context "when the folder exists" do
-    let(:email3) { send_email folder, msg3 }
-
-    context "when the uid_validity matches" do
-      let(:pre) do
-        server_create_folder folder
-        email3
-        uid_validity
-      end
-      let(:messages_as_server_messages) do
-        [
-          message_as_server_message(msg3),
-          message_as_server_message(msg1),
-          message_as_server_message(msg2)
-        ]
-      end
-      let(:uid_validity) { server_uid_validity(folder) }
-
-      it "appends to the existing folder" do
-        messages = server_messages(folder).map { |m| server_message_to_body(m) }
-        expect(messages).to eq(messages_as_server_messages)
-      end
-    end
-
-    context "when the uid_validity doesn't match" do
-      context "when the folder is empty" do
-        let(:pre) do
-          server_create_folder folder
-        end
-
-        it "sets the backup uid_validity to match the folder" do
-          updated_imap_content = imap_parsed(folder)
-          expect(updated_imap_content[:uid_validity]).
-            to eq(server_uid_validity(folder))
-        end
-
-        it "uploads to the new folder" do
-          messages = server_messages(folder).map do |m|
-            server_message_to_body(m)
-          end
-          expect(messages).to eq(messages_as_server_messages)
-        end
-      end
-
-      context "when the folder has content" do
-        let(:new_folder) { "#{folder}-#{uid_validity}" }
-        let(:cleanup) do
-          server_delete_folder new_folder
-          super()
-        end
-
-        let(:pre) do
-          server_create_folder folder
-          email3
-        end
-
-        it "renames the backup" do
-          expect(mbox_content(new_folder)).to eq(messages_as_mbox)
-        end
-
-        it "leaves the existing folder as is" do
-          messages = server_messages(folder).map do |m|
-            server_message_to_body(m)
-          end
-          expect(messages).to eq([message_as_server_message(msg3)])
-        end
-
-        it "creates the new folder" do
-          expect(server_folders.map(&:name)).to include(new_folder)
-        end
-
-        it "sets the backup uid_validity to match the new folder" do
-          updated_imap_content = imap_parsed(new_folder)
-          expect(updated_imap_content[:uid_validity]).
-            to eq(server_uid_validity(new_folder))
-        end
-
-        it "uploads to the new folder" do
-          messages = server_messages(new_folder).map do |m|
-            server_message_to_body(m)
-          end
-          expect(messages).to eq(messages_as_server_messages)
-        end
-      end
-    end
-  end
-
-  context "when non-Unicode encodings are used" do
-    let(:server_message) do
-      message_as_server_message(msg_iso8859)
-    end
-    let(:messages_as_mbox) do
-      message_as_mbox_entry(msg_iso8859)
-    end
-    let(:message_uids) { [uid_iso8859] }
-    let(:uid_validity) { server_uid_validity(folder) }
-
-    let(:pre) do
-      server_create_folder folder
-      uid_validity
-    end
-
-    it "maintains encodings" do
-      message =
-        server_messages(folder).
-        first["BODY[]"]
-
-      expect(message).to eq(server_message)
-    end
-  end
-end

data/spec/features/status_spec.rb

@@ -1,43 +0,0 @@
-require "features/helper"
-require "imap/backup/cli/status"
-
-RSpec.describe "status", type: :feature, docker: true do
-  include_context "imap-backup connection"
-  include_context "message-fixtures"
-
-  context "when there are non-backed-up messages" do
-    let(:options) do
-      {accounts: "address@example.org"}
-    end
-    let(:folder) { "my-stuff" }
-    let(:backup_folders) { [{name: folder}] }
-    let(:email1) { send_email folder, msg1 }
-    let(:output) { StringIO.new }
-
-    before do
-      allow(Imap::Backup::CLI::Accounts).to receive(:new) { [account] }
-      server_create_folder folder
-      email1
-    end
-
-    around do |example|
-      stdout = $stdout
-      $stdout = output
-      example.run
-      $stdout = stdout
-    end
-
-    after do
-      FileUtils.rm_rf local_backup_path
-      delete_emails folder
-      server_delete_folder folder
-      connection.disconnect
-    end
-
-    it "prints the number" do
-      Imap::Backup::CLI::Status.new(options).run
-
-      expect(output.string).to eq("address@example.org\nmy-stuff: 1\n")
-    end
-  end
-end

data/spec/features/support/aruba.rb

@@ -1,78 +0,0 @@
-require "aruba/rspec"
-
-require_relative "backup_directory"
-require "imap/backup/serializer/mbox"
-
-Aruba.configure do |config|
-  config.home_directory = File.expand_path("./tmp/home")
-  config.allow_absolute_paths = true
-end
-
-module ConfigurationHelpers
-  def config_path
-    File.expand_path("~/.imap-backup")
-  end
-
-  def create_config(accounts:, debug: false)
-    pathname = File.join(config_path, "config.json")
-    save_data = {
-      version: Imap::Backup::Configuration::VERSION,
-      accounts: accounts,
-      debug: debug
-    }
-    FileUtils.mkdir_p config_path
-    File.open(pathname, "w") { |f| f.write(JSON.pretty_generate(save_data)) }
-    FileUtils.chmod(0o600, pathname)
-  end
-end
-
-module StoreHelpers
-  def store_email(
-    email:, folder:,
-    uid: 1,
-    from: "sender@example.com",
-    subject: "The Subject",
-    body: "body"
-  )
-    account = config.accounts.find { |a| a.username == email }
-    raise "Account not found" if !account
-    FileUtils.mkdir_p account.local_path
-    serializer = Imap::Backup::Serializer.new(account.local_path, folder)
-    serializer.force_uid_validity("42") if !serializer.uid_validity
-    serialized = to_serialized(from: from, subject: subject, body: body)
-    serializer.append uid, serialized
-  end
-
-  def to_serialized(from:, subject:, body:)
-    body_and_headers = <<~BODY
-      From: #{from}
-      Subject: #{subject}
-
-      #{body}
-    BODY
-  end
-
-  def config
-    Imap::Backup::Configuration.new(
-      File.expand_path("~/.imap-backup/config.json")
-    )
-  end
-end
-
-RSpec.configure do |config|
-  config.include ConfigurationHelpers, type: :aruba
-  config.include StoreHelpers, type: :aruba
-  config.include BackupDirectoryHelpers, type: :aruba
-
-  config.before(:suite) do
-    FileUtils.rm_rf "./tmp/home"
-  end
-
-  config.before(:example, type: :aruba) do
-    set_environment_variable("COVERAGE", "aruba")
-  end
-
-  config.after do
-    FileUtils.rm_rf "./tmp/home"
-  end
-end

data/spec/features/support/backup_directory.rb

@@ -1,43 +0,0 @@
-module BackupDirectoryHelpers
-  def message_as_mbox_entry(options)
-    from = fixture("connection")[:username]
-    subject = options[:subject]
-    body = options[:body]
-    body_and_headers = <<~BODY
-      From: #{from}
-      Subject: #{subject}
-
-      #{body}
-    BODY
-
-    "From #{from}\n#{body_and_headers}\n"
-  end
-
-  def imap_data(uid_validity, uids)
-    {
-      version: 2,
-      uid_validity: uid_validity,
-      uids: uids
-    }
-  end
-
-  def mbox_content(name)
-    File.read(mbox_path(name))
-  end
-
-  def mbox_path(name)
-    File.join(local_backup_path, "#{name}.mbox")
-  end
-
-  def imap_path(name)
-    File.join(local_backup_path, "#{name}.imap")
-  end
-
-  def imap_content(name)
-    File.read(imap_path(name))
-  end
-
-  def imap_parsed(name)
-    JSON.parse(imap_content(name), symbolize_names: true)
-  end
-end

data/spec/features/support/email_server.rb

@@ -1,110 +0,0 @@
-module EmailServerHelpers
-  REQUESTED_ATTRIBUTES = ["BODY[]"].freeze
-  DEFAULT_EMAIL = "address@example.org".freeze
-
-  def send_email(folder, options)
-    message = message_as_server_message(options)
-    imap.append(folder, message, nil, nil)
-  end
-
-  def message_as_server_message(options)
-    from = options[:from] || DEFAULT_EMAIL
-    subject = options[:subject]
-    body = options[:body]
-
-    <<~MESSAGE.gsub("\n", "\r\n")
-      From: #{from}
-      Subject: #{subject}
-
-      #{body}
-
-    MESSAGE
-  end
-
-  def server_messages(folder)
-    server_uids(folder).map do |uid|
-      server_fetch_email(folder, uid)
-    end
-  end
-
-  def server_message_to_body(message)
-    message["BODY[]"]
-  end
-
-  def server_fetch_email(folder, uid)
-    examine folder
-
-    fetch_data_items = imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
-    return nil if fetch_data_items.nil?
-
-    fetch_data_item = fetch_data_items[0]
-    fetch_data_item.attr
-  end
-
-  def delete_emails(folder)
-    imap.select(folder)
-    uids = imap.uid_search(["ALL"]).sort
-    imap.store(1..uids.size, "+FLAGS", [:Deleted])
-    imap.expunge
-  end
-
-  def examine(folder)
-    imap.examine(folder)
-  end
-
-  def server_uids(folder)
-    examine(folder)
-    imap.uid_search(["ALL"]).sort
-  end
-
-  def server_uid_validity(folder)
-    examine(folder)
-    imap.responses["UIDVALIDITY"][0]
-  end
-
-  def server_folders
-    imap.list(root, "*")
-  end
-
-  def root
-    root_info = imap.list("", "")[0]
-    root_info.name
-  end
-
-  def server_create_folder(folder)
-    imap.create(folder)
-    imap.disconnect
-    @imap = nil
-  end
-
-  def server_rename_folder(from, to)
-    imap.rename(from, to)
-    imap.disconnect
-    @imap = nil
-  end
-
-  def server_delete_folder(folder)
-    imap.delete folder
-    imap.disconnect
-  rescue StandardError => e
-  ensure
-    @imap = nil
-  end
-
-  def imap
-    @imap ||=
-      begin
-        connection = fixture("connection")
-        imap = Net::IMAP.new(
-          connection[:server], connection[:connection_options]
-        )
-        imap.login(connection[:username], connection[:password])
-        imap
-      end
-  end
-end
-
-RSpec.configure do |config|
-  config.include EmailServerHelpers, type: :aruba
-  config.include EmailServerHelpers, type: :feature
-end

data/spec/features/support/shared/connection_context.rb

@@ -1,14 +0,0 @@
-shared_context "imap-backup connection" do
-  let(:local_backup_path) { Dir.mktmpdir(nil, "tmp") }
-  let(:default_connection) { fixture("connection") }
-  let(:backup_folders) { nil }
-  let(:account) do
-    Imap::Backup::Account.new(
-      default_connection.merge(
-        local_path: local_backup_path,
-        folders: backup_folders
-      )
-    )
-  end
-  let(:connection) { Imap::Backup::Account::Connection.new(account) }
-end

data/spec/features/support/shared/message_fixtures.rb

@@ -1,16 +0,0 @@
-shared_context "message-fixtures" do
-  let(:uid1) { 123 }
-  let(:uid2) { 345 }
-  let(:uid3) { 567 }
-  let(:uid_iso8859) { 890 }
-  let(:msg1) { {uid: uid1, subject: "Test 1", body: "body 1\nHi"} }
-  let(:msg2) { {uid: uid2, subject: "Test 2", body: "body 2"} }
-  let(:msg3) { {uid: uid3, subject: "Test 3", body: "body 3"} }
-  let(:msg_iso8859) do
-    {
-      uid: uid_iso8859,
-      subject: "iso8859 Body",
-      body: "Ma, perchè?".encode(Encoding::ISO_8859_1).force_encoding("binary")
-    }
-  end
-end

data/spec/fixtures/connection.yml

@@ -1,7 +0,0 @@
-:server: 'localhost'
-:username: 'address@example.org'
-:password: 'pass'
-:connection_options:
-  :port: <%= ENV.fetch("DOCKER_IMAP_SERVER", 8993) %>
-  :ssl:
-    :verify_mode: 0

data/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-require "rspec"
-
-$LOAD_PATH << File.expand_path("../lib", __dir__)
-
-support_glob = File.join(__dir__, "support", "**", "*.rb")
-Dir[support_glob].sort.each { |f| require f }
-
-require "simplecov"
-
-SimpleCov.command_name "RSpec tests"
-
-require "imap/backup"
-require "imap/backup/cli"
-
-silence_logging

data/spec/support/fixtures.rb

@@ -1,11 +0,0 @@
-require "erb"
-require "yaml"
-
-def fixture(name)
-  spec_root = File.expand_path("..", File.dirname(__FILE__))
-  fixture_path = File.join(spec_root, "fixtures", "#{name}.yml")
-  content = File.read(fixture_path)
-  template = ERB.new(content)
-  yaml = template.result(binding)
-  YAML.safe_load(yaml, [Symbol])
-end

data/spec/support/higline_test_helpers.rb

@@ -1,8 +0,0 @@
-module HighLineTestHelpers
-  def prepare_highline
-    @input = instance_double(IO, eof?: false, gets: "q\n")
-    @output = StringIO.new
-    Imap::Backup::Setup.highline = HighLine.new(@input, @output)
-    [@input, @output]
-  end
-end

data/spec/support/silence_logging.rb

@@ -1,7 +0,0 @@
-def silence_logging
-  RSpec.configure do |config|
-    config.before(:suite) do
-      Imap::Backup::Logger.logger.level = Logger::UNKNOWN
-    end
-  end
-end

data/spec/unit/email/mboxrd/message_spec.rb

@@ -1,177 +0,0 @@
-msg_no_from = <<~NO_FROM
-  Delivered-To: you@example.com
-  From: example <www.example.com>
-  To: FirstName LastName <you@example.com>
-  Subject: Re: no subject
-NO_FROM
-
-msg_bad_from = <<~BAD_FROM
-  Delivered-To: you@example.com
-  from: "FirstName LastName (TEXT)" <"TEXT*" <no-reply@example.com>>
-  To: FirstName LastName <you@example.com>
-  Subject: Re: no subject
-BAD_FROM
-
-msg_no_from_but_return_path = <<~RETURN_PATH
-  Delivered-To: you@example.com
-  From: example <www.example.com>
-  To: FirstName LastName <you@example.com>
-  Return-Path: <me@example.com>
-  Subject: Re: no subject
-RETURN_PATH
-
-msg_no_from_but_sender = <<~NOT_SENDER
-  Delivered-To: you@example.com
-  To: FirstName LastName <you@example.com>
-  Subject: Re: no subject
-  Sender: FistName LastName <me@example.com>
-NOT_SENDER
-
-describe Email::Mboxrd::Message do
-  subject { described_class.new(message_body) }
-
-  let(:from) { "me@example.com" }
-  let(:date) { DateTime.new(2012, 12, 13, 18, 23, 45) }
-  let(:message_body) do
-    instance_double(String, clone: cloned_message_body, force_encoding: nil)
-  end
-  let(:cloned_message_body) do
-    "Foo\nBar\nFrom at the beginning of the line\n>>From quoted"
-  end
-  let(:msg_good) do
-    <<~GOOD
-      Delivered-To: you@example.com
-      From: Foo <foo@example.com>
-      To: FirstName LastName <you@example.com>
-      Date: #{date.rfc822}
-      Subject: Re: no subject
-    GOOD
-  end
-
-  let(:msg_bad_date) do
-    <<~BAD
-      Delivered-To: you@example.com
-      From: Foo <foo@example.com>
-      To: FirstName LastName <you@example.com>
-      Date: Mon,5 May 2014 08:97:99 GMT
-      Subject: Re: no subject
-    BAD
-  end
-
-  describe ".from_serialized" do
-    let(:serialized_message) { "From foo@a.com\n#{imap_message}" }
-    let(:imap_message) { "Delivered-To: me@example.com\nFrom Me\n" }
-    let!(:result) { described_class.from_serialized(serialized_message) }
-
-    it "returns the message" do
-      expect(result).to be_a(described_class)
-    end
-
-    it "removes one level of > before From" do
-      expect(result.supplied_body).to eq(imap_message)
-    end
-  end
-
-  describe "#to_serialized" do
-    let(:mail) { instance_double(Mail::Message, from: [from], date: date) }
-
-    before do
-      allow(Mail).to receive(:new).with(cloned_message_body) { mail }
-    end
-
-    it "adds a 'From ' line at the start" do
-      expected = "From #{from} #{date.asctime}\n"
-      expect(subject.to_serialized).to start_with(expected)
-    end
-
-    it "replaces existing 'From ' with '>From '" do
-      expect(subject.to_serialized).to include("\n>From at the beginning")
-    end
-
-    it "appends > before '>+From '" do
-      expect(subject.to_serialized).to include("\n>>>From quoted")
-    end
-
-    context "when date is missing" do
-      let(:date) { nil }
-
-      it "does no fail" do
-        expect { subject.to_serialized }.to_not raise_error
-      end
-    end
-  end
-
-  describe "From" do
-    before do
-      # call original for these tests because we want to test the behaviour of
-      # class-under-test given different behaviour of the Mail parser
-      allow(Mail).to receive(:new).and_call_original
-    end
-
-    context "when original message 'from' is missing" do
-      let(:message_body) { msg_no_from }
-
-      it "'from' is empty string" do
-        expect(subject.to_serialized).to start_with("From \n")
-      end
-    end
-
-    context "when original message 'from' is not a well-formed address" do
-      let(:message_body) { msg_bad_from }
-
-      it "'from' is empty string" do
-        expect(subject.to_serialized).to start_with("From \n")
-      end
-    end
-
-    context "when original message 'from' is nil and " \
-      "'envelope from' is nil and 'return path' is available" do
-      let(:message_body) { msg_no_from_but_return_path }
-
-      it "'return path' is used as 'from'" do
-        expect(subject.to_serialized).to start_with("From #{from}\n")
-      end
-    end
-
-    context "with no from and a 'Sender'" do
-      let(:message_body) { msg_no_from_but_sender }
-
-      it "Sender is used as 'from'" do
-        expect(subject.to_serialized).to start_with("From #{from}\n")
-      end
-    end
-  end
-
-  describe "#date" do
-    let(:message_body) { msg_good }
-
-    it "returns the date" do
-      expect(subject.date).to eq(date)
-    end
-
-    context "with incorrect minutes and seconds" do
-      let(:message_body) { msg_bad_date }
-
-      it "returns nil" do
-        expect(subject.date).to be_nil
-      end
-    end
-  end
-
-  describe "#imap_body" do
-    let(:message_body) { "Ciao" }
-
-    it "returns the supplied body" do
-      expect(subject.imap_body).to eq(message_body)
-    end
-
-    context "when newlines are not IMAP standard" do
-      let(:message_body) { "Ciao\nHello" }
-      let(:corrected) { "Ciao\r\nHello" }
-
-      it "corrects them" do
-        expect(subject.imap_body).to eq(corrected)
-      end
-    end
-  end
-end