imap-backup 5.2.0 → 6.0.1

data/spec/unit/imap/backup/serializer/mbox_store_spec.rb

@@ -1,329 +0,0 @@
-describe Imap::Backup::Serializer::MboxStore do
-  subject { described_class.new(base_path, folder) }
-
-  let(:base_path) { "/base/path" }
-  let(:folder) { "the/folder" }
-  let(:folder_path) { File.join(base_path, folder) }
-  let(:imap_pathname) { "#{folder_path}.imap" }
-  let(:imap_exists) { true }
-  let(:imap_file) { instance_double(File, write: nil, close: nil) }
-  let(:mbox_pathname) { "#{folder_path}.mbox" }
-  let(:mbox_exists) { true }
-  let(:mbox_file) { instance_double(File, write: nil, close: nil) }
-  let(:uids) { [3, 2, 1] }
-  let(:imap_content) do
-    {
-      version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
-      uid_validity: uid_validity,
-      uids: uids
-    }.to_json
-  end
-  let(:uid_validity) { 123 }
-
-  before do
-    allow(File).to receive(:exist?).and_call_original
-    allow(File).to receive(:exist?).with(imap_pathname) { imap_exists }
-    allow(File).to receive(:exist?).with(mbox_pathname) { mbox_exists }
-
-    allow(File).to receive(:open).and_call_original
-    allow(File).
-      to receive(:open).with("/base/path/my/folder.imap") { imap_content }
-    allow(File).to receive(:open).with(imap_pathname, "w").and_yield(imap_file)
-    allow(File).to receive(:open).with(mbox_pathname, "w").and_yield(mbox_file)
-
-    allow(File).to receive(:read).and_call_original
-    allow(File).to receive(:read).with(imap_pathname) { imap_content }
-
-    allow(File).to receive(:unlink).and_call_original
-    allow(File).to receive(:unlink).with(imap_pathname)
-    allow(File).to receive(:unlink).with(mbox_pathname)
-
-    allow(FileUtils).to receive(:chmod)
-  end
-
-  describe "#uid_validity=" do
-    let(:new_uid_validity) { "13" }
-    let(:updated_imap_content) do
-      {
-        version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
-        uid_validity: new_uid_validity,
-        uids: uids
-      }.to_json
-    end
-
-    it "sets uid_validity" do
-      subject.uid_validity = new_uid_validity
-
-      expect(subject.uid_validity).to eq(new_uid_validity)
-    end
-
-    it "writes the imap file" do
-      expect(imap_file).to receive(:write).with(updated_imap_content)
-
-      subject.uid_validity = new_uid_validity
-    end
-  end
-
-  describe "#uids" do
-    it "returns the backed-up uids as integers" do
-      expect(subject.uids).to eq(uids.map(&:to_i))
-    end
-
-    context "when the imap file does not exist" do
-      let(:imap_exists) { false }
-
-      it "returns an empty Array" do
-        expect(subject.uids).to eq([])
-      end
-    end
-
-    context "when the imap file is malformed" do
-      before do
-        allow(JSON).to receive(:parse).and_raise(JSON::ParserError)
-      end
-
-      it "returns an empty Array" do
-        expect(subject.uids).to eq([])
-      end
-
-      it "deletes the imap file" do
-        expect(File).to receive(:unlink).with(imap_pathname)
-
-        subject.uids
-      end
-
-      it "deletes the mbox file" do
-        expect(File).to receive(:unlink).with(mbox_pathname)
-
-        subject.uids
-      end
-
-      it "writes a blank mbox file" do
-        expect(mbox_file).to receive(:write).with("")
-
-        subject.uids
-      end
-    end
-
-    context "when the mbox does not exist" do
-      let(:mbox_exists) { false }
-
-      it "returns an empty Array" do
-        expect(subject.uids).to eq([])
-      end
-    end
-  end
-
-  describe "#add" do
-    let(:mbox_formatted_message) { "message in mbox format" }
-    let(:message_uid) { "999" }
-    let(:message) do
-      instance_double(
-        Email::Mboxrd::Message,
-        to_serialized: mbox_formatted_message
-      )
-    end
-    let(:updated_imap_content) do
-      {
-        version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
-        uid_validity: uid_validity,
-        uids: uids + [999]
-      }.to_json
-    end
-
-    before do
-      allow(Email::Mboxrd::Message).to receive(:new) { message }
-      allow(File).to receive(:open).with(mbox_pathname, "ab") { mbox_file }
-    end
-
-    it "saves the message to the mbox" do
-      expect(mbox_file).to receive(:write).with(mbox_formatted_message)
-
-      subject.add(message_uid, "The\nemail\n")
-    end
-
-    it "saves the uid to the imap file" do
-      expect(imap_file).to receive(:write).with(updated_imap_content)
-
-      subject.add(message_uid, "The\nemail\n")
-    end
-
-    context "when the message is already downloaded" do
-      let(:uids) { [999] }
-
-      it "skips the message" do
-        expect(mbox_file).to_not receive(:write)
-
-        subject.add(message_uid, "The\nemail\n")
-      end
-    end
-
-    context "when the message causes parsing errors" do
-      before do
-        allow(message).to receive(:to_serialized).and_raise(ArgumentError)
-      end
-
-      it "skips the message" do
-        expect(mbox_file).to_not receive(:write)
-
-        subject.add(message_uid, "The\nemail\n")
-      end
-
-      it "does not fail" do
-        expect do
-          subject.add(message_uid, "The\nemail\n")
-        end.to_not raise_error
-      end
-    end
-  end
-
-  describe "#load" do
-    let(:uid) { "1" }
-    let(:enumerator) do
-      instance_double(Imap::Backup::Serializer::MboxEnumerator)
-    end
-    let(:enumeration) { instance_double(Enumerator) }
-
-    before do
-      allow(Imap::Backup::Serializer::MboxEnumerator).
-        to receive(:new) { enumerator }
-      allow(enumerator).to receive(:each) { enumeration }
-      allow(enumeration).
-        to receive(:with_index).
-        and_yield("", 0).
-        and_yield("", 1).
-        and_yield("ciao", 2)
-    end
-
-    it "returns the message" do
-      expect(subject.load(uid).supplied_body).to eq("ciao")
-    end
-
-    context "when the UID is unknown" do
-      let(:uid) { "99" }
-
-      it "returns nil" do
-        expect(subject.load(uid)).to be_nil
-      end
-    end
-  end
-
-  describe "#each_message" do
-    let(:enumerator) do
-      instance_double(Imap::Backup::Serializer::MboxEnumerator)
-    end
-    let(:enumeration) { instance_double(Enumerator) }
-
-    before do
-      allow(Imap::Backup::Serializer::MboxEnumerator).
-        to receive(:new) { enumerator }
-      allow(enumerator).to receive(:each) { enumeration }
-      allow(enumeration).
-        to receive(:with_index).
-        and_yield("", 0).
-        and_yield("", 1).
-        and_yield("ciao", 2)
-    end
-
-    it "yields messages" do
-      expect { |b| subject.each_message([1], &b) }.
-        to yield_successive_args([1, instance_of(Email::Mboxrd::Message)])
-    end
-
-    it "yields the requested message uid" do
-      subject.each_message([1]) do |uid, _message|
-        expect(uid).to eq(1)
-      end
-    end
-
-    it "yields the requested message" do
-      subject.each_message([1]) do |_uid, message|
-        expect(message.supplied_body).to eq("ciao")
-      end
-    end
-
-    context "without a block" do
-      it "returns an Enumerator" do
-        expect(subject.each_message([1])).to be_a(Enumerator)
-      end
-    end
-  end
-
-  describe "#update_uid" do
-    let(:old_uid) { "2" }
-    let(:updated_imap_content) do
-      {
-        version: Imap::Backup::Serializer::MboxStore::CURRENT_VERSION,
-        uid_validity: uid_validity,
-        uids: [3, 999, 1]
-      }.to_json
-    end
-
-    it "updates the stored UID" do
-      expect(imap_file).to receive(:write).with(updated_imap_content)
-
-      subject.update_uid(old_uid, "999")
-    end
-
-    context "when the UID is unknown" do
-      let(:old_uid) { "42" }
-
-      it "does nothing" do
-        expect(imap_file).to_not receive(:write)
-
-        subject.update_uid(old_uid, "999")
-      end
-    end
-  end
-
-  describe "#reset" do
-    it "deletes the imap file" do
-      expect(File).to receive(:unlink).with(imap_pathname)
-
-      subject.reset
-    end
-
-    it "deletes the mbox file" do
-      expect(File).to receive(:unlink).with(mbox_pathname)
-
-      subject.reset
-    end
-
-    it "writes a blank mbox file" do
-      expect(mbox_file).to receive(:write).with("")
-
-      subject.reset
-    end
-  end
-
-  describe "#rename" do
-    let(:new_name) { "new_name" }
-    let(:new_folder_path) { File.join(base_path, new_name) }
-    let(:new_imap_name) { "#{new_folder_path}.imap" }
-    let(:new_mbox_name) { "#{new_folder_path}.mbox" }
-
-    before do
-      allow(File).to receive(:rename).and_call_original
-      allow(File).to receive(:rename).with(imap_pathname, new_imap_name)
-      allow(File).to receive(:rename).with(mbox_pathname, new_mbox_name)
-    end
-
-    it "renames the imap file" do
-      expect(File).to receive(:rename).with(imap_pathname, new_imap_name)
-
-      subject.rename(new_name)
-    end
-
-    it "renames the mbox file" do
-      expect(File).to receive(:rename).with(mbox_pathname, new_mbox_name)
-
-      subject.rename(new_name)
-    end
-
-    it "updates the folder name" do
-      subject.rename(new_name)
-
-      expect(subject.folder).to eq(new_name)
-    end
-  end
-end

data/spec/unit/imap/backup/setup/account_spec.rb

@@ -1,366 +0,0 @@
-describe Imap::Backup::Setup::Account do
-  ACCOUNT = "account".freeze
-  GMAIL_IMAP_SERVER = "imap.gmail.com".freeze
-  HIGHLINE = "highline".freeze
-  CONFIG = "config".freeze
-
-  subject { described_class.new(config, account, highline) }
-
-  let(:account) do
-    instance_double(
-      Imap::Backup::Account,
-      username: existing_email,
-      password: existing_password,
-      server: current_server,
-      connection_options: nil,
-      local_path: "/backup/path",
-      folders: [{name: "my_folder"}],
-      modified?: false
-    )
-  end
-  let(:account1) do
-    instance_double(
-      Imap::Backup::Account,
-      username: other_email,
-      local_path: other_existing_path
-    )
-  end
-  let(:accounts) { [account, account1] }
-  let(:existing_email) { "user@example.com" }
-  let(:new_email) { "foo@example.com" }
-  let(:current_server) { "imap.example.com" }
-  let(:existing_password) { "password" }
-  let(:other_email) { "other@example.com" }
-  let(:other_existing_path) { "/other/existing/path" }
-
-  let(:highline) { HIGHLINE }
-  let(:config) { CONFIG }
-
-  describe "#initialize" do
-    [:config, :account, :highline].each do |param|
-      it "expects #{param}" do
-        expect(subject.send(param)).to eq(send(param))
-      end
-    end
-  end
-
-  describe "#run" do
-    let(:highline_menu_class) do
-      Class.new do
-        attr_reader :choices
-        attr_accessor :header
-
-        def initialize
-          @choices = {}
-        end
-
-        def choice(name, &block)
-          choices[name] = block
-        end
-
-        def hidden(name, &block)
-          choices[name] = block
-        end
-      end
-    end
-
-    let(:highline) { instance_double(HighLine) }
-    let(:menu) { highline_menu_class.new }
-    let(:config) do
-      instance_double(Imap::Backup::Configuration, accounts: accounts)
-    end
-
-    before do
-      allow(Kernel).to receive(:system)
-      allow(Kernel).to receive(:puts)
-      allow(highline).to receive(:choose) do |&block|
-        block.call(menu)
-        throw :done
-      end
-    end
-
-    describe "preparation" do
-      it "clears the screen" do
-        expect(Kernel).to receive(:system).with("clear")
-
-        subject.run
-      end
-
-      describe "menu" do
-        it "shows the menu" do
-          expect(highline).to receive(:choose)
-
-          subject.run
-        end
-      end
-    end
-
-    describe "menu" do
-      [
-        "modify email",
-        "modify password",
-        "modify server",
-        "modify backup path",
-        "choose backup folders",
-        "test connection",
-        "delete",
-        "(q) return to main menu",
-        "quit" # TODO: quit is hidden
-      ].each do |item|
-        before { subject.run }
-
-        it "has a '#{item}' item" do
-          expect(menu.choices).to include(item)
-        end
-      end
-    end
-
-    describe "account details" do
-      [
-        ["email", /email\s+user@example.com/],
-        ["password", /password\s+x+/],
-        ["path", %r(path\s+/backup/path)],
-        ["folders", /folders\s+my_folder/],
-        ["server", /server\s+imap.example.com/]
-      ].each do |attribute, value|
-        before { subject.run }
-
-        it "shows the #{attribute}" do
-          expect(menu.header).to match(value)
-        end
-      end
-
-      context "with no password" do
-        let(:existing_password) { "" }
-
-        before { subject.run }
-
-        it "indicates that a password is not set" do
-          expect(menu.header).to include("password   (unset)")
-        end
-      end
-    end
-
-    describe "choosing 'modify email'" do
-      before do
-        allow(account).to receive(:"username=")
-        allow(account).to receive(:"server=")
-        allow(Imap::Backup::Setup::Asker).
-          to receive(:email) { new_email }
-        subject.run
-        menu.choices["modify email"].call
-      end
-
-      context "when the server is blank" do
-        [
-          ["GMail", "foo@gmail.com", GMAIL_IMAP_SERVER],
-          ["Fastmail", "bar@fastmail.fm", "imap.fastmail.com"],
-          ["Fastmail", "bar@fastmail.com", "imap.fastmail.com"]
-        ].each do |service, email, expected|
-          context service do
-            let(:new_email) { email }
-
-            context "with nil" do
-              let(:current_server) { nil }
-
-              it "sets a default server" do
-                expect(account).to have_received(:"server=").with(expected)
-              end
-            end
-
-            context "with an empty string" do
-              let(:current_server) { "" }
-
-              it "sets a default server" do
-                expect(account).to have_received(:"server=").with(expected)
-              end
-            end
-          end
-        end
-
-        context "when the domain is unrecognized" do
-          let(:current_server) { nil }
-          let(:provider) do
-            instance_double(Email::Provider, provider: :default)
-          end
-
-          before do
-            allow(Email::Provider).to receive(:for_address) { provider }
-          end
-
-          it "does not set a default server" do
-            expect(account).to_not have_received(:"server=")
-          end
-        end
-      end
-
-      context "when the email is new" do
-        it "modifies the email address" do
-          expect(account).to have_received(:"username=").with(new_email)
-        end
-      end
-
-      context "when the email already exists" do
-        let(:new_email) { other_email }
-
-        it "indicates the error" do
-          expect(Kernel).to have_received(:puts).
-            with("There is already an account set up with that email address")
-        end
-
-        it "doesn't set the email" do
-          expect(account.username).to eq(existing_email)
-        end
-      end
-    end
-
-    describe "choosing 'modify password'" do
-      let(:new_password) { "new_password" }
-
-      before do
-        allow(account).to receive(:"password=")
-        allow(Imap::Backup::Setup::Asker).
-          to receive(:password) { new_password }
-        subject.run
-        menu.choices["modify password"].call
-      end
-
-      context "when the user enters a password" do
-        it "updates the password" do
-          expect(account).to have_received(:"password=").with(new_password)
-        end
-      end
-
-      context "when the user cancels" do
-        let(:new_password) { nil }
-
-        it "does nothing" do
-          expect(account.password).to eq(existing_password)
-        end
-      end
-    end
-
-    describe "choosing 'modify server'" do
-      let(:server) { "server" }
-
-      before do
-        allow(account).to receive(:"server=")
-        allow(highline).to receive(:ask).with("server: ") { server }
-
-        subject.run
-
-        menu.choices["modify server"].call
-      end
-
-      it "updates the server" do
-        expect(account).to have_received(:"server=").with(server)
-      end
-    end
-
-    describe "choosing 'modify backup path'" do
-      let(:new_backup_path) { "/new/path" }
-
-      before do
-        allow(account).to receive(:"local_path=")
-        @validator = nil
-        allow(
-          Imap::Backup::Setup::Asker
-        ).to receive(:backup_path) do |_path, validator|
-          @validator = validator
-          new_backup_path
-        end
-        subject.run
-        menu.choices["modify backup path"].call
-      end
-
-      it "updates the path" do
-        expect(account).to have_received(:"local_path=").with(new_backup_path)
-      end
-
-      context "when the path is not used by other backups" do
-        it "is accepts it" do
-          # rubocop:disable RSpec/InstanceVariable
-          expect(@validator.call("/unknown/path")).to be_truthy
-          # rubocop:enable RSpec/InstanceVariable
-        end
-      end
-
-      context "when the path is used by other backups" do
-        it "fails validation" do
-          # rubocop:disable RSpec/InstanceVariable
-          expect(@validator.call(other_existing_path)).to be_falsey
-          # rubocop:enable RSpec/InstanceVariable
-        end
-      end
-    end
-
-    describe "choosing 'choose backup folders'" do
-      let(:chooser) do
-        instance_double(Imap::Backup::Setup::FolderChooser, run: nil)
-      end
-
-      before do
-        allow(Imap::Backup::Setup::FolderChooser).
-          to receive(:new) { chooser }
-        subject.run
-        menu.choices["choose backup folders"].call
-      end
-
-      it "edits folders" do
-        expect(chooser).to have_received(:run)
-      end
-    end
-
-    describe "choosing 'test connection'" do
-      let(:connection_tester) do
-        instance_double(
-          Imap::Backup::Setup::ConnectionTester,
-          test: "All fine"
-        )
-      end
-
-      before do
-        allow(Imap::Backup::Setup::ConnectionTester).
-          to receive(:new) { connection_tester }
-        allow(highline).to receive(:ask)
-        subject.run
-        menu.choices["test connection"].call
-      end
-
-      it "tests the connection" do
-        expect(connection_tester).to have_received(:test)
-      end
-    end
-
-    describe "choosing 'delete'" do
-      let(:confirmed) { true }
-
-      before do
-        allow(account).to receive(:mark_for_deletion!)
-        allow(highline).to receive(:agree) { confirmed }
-        subject.run
-        catch :done do
-          menu.choices["delete"].call
-        end
-      end
-
-      it "asks for confirmation" do
-        expect(highline).to have_received(:agree)
-      end
-
-      context "when the user confirms deletion" do
-        it "flags the account to be deleted" do
-          expect(account).to have_received(:mark_for_deletion!)
-        end
-      end
-
-      context "without confirmation" do
-        let(:confirmed) { false }
-
-        it "doesn't flag the account to be deleted" do
-          expect(account).to_not have_received(:mark_for_deletion!)
-        end
-      end
-    end
-  end
-end