imap-backup 5.2.0 → 6.0.1

data/spec/features/migrate_spec.rb

@@ -1,35 +0,0 @@
-require "features/helper"
-
-RSpec.describe "Migration", type: :aruba, docker: true do
-  let(:email) { "me@example.com" }
-  let(:folder) { "my_folder" }
-  let(:source_account) do
-    {
-      username: email,
-      local_path: File.join(config_path, email.gsub("@", "_"))
-    }
-  end
-  let(:destination_account) { fixture("connection") }
-
-  before do
-    create_config(accounts: [source_account, destination_account])
-    store_email(email: email, folder: folder, subject: "Ciao")
-    run_command_and_stop("imap-backup migrate #{email} #{destination_account[:username]}")
-  end
-
-  after do
-    delete_emails(folder)
-  end
-
-  it "copies email to the destination account" do
-    messages = server_messages(folder)
-    expected = <<~MESSAGE.gsub("\n", "\r\n")
-      From: sender@example.com
-      Subject: Ciao
-
-      body
-
-    MESSAGE
-    expect(messages[0]["BODY[]"]).to eq(expected)
-  end
-end

data/spec/features/remote/list_account_folders_spec.rb

@@ -1,16 +0,0 @@
-require "features/helper"
-
-RSpec.describe "List account folders", type: :aruba do
-  let(:account) do
-    fixture("connection")
-  end
-
-  before do
-    create_config(accounts: [account])
-    run_command_and_stop("imap-backup remote folders #{account[:username]}")
-  end
-
-  it "lists folders" do
-    expect(last_command_started).to have_output(/"INBOX"/)
-  end
-end

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,77 +0,0 @@
-require "aruba/rspec"
-
-require_relative "backup_directory"
-
-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
-    store = Imap::Backup::Serializer::MboxStore.new(account.local_path, folder)
-    store.uid_validity = "42" if !store.uid_validity
-    serialized = to_serialized(from: from, subject: subject, body: body)
-    store.add(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