imap-backup 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 3f897dc0bac78683c9cae100718a03cf934adc0348866a4688ce5d2196bbdcfa
-  data.tar.gz: 164bc47c5acb9e448b3c61e6d58d18c3f48cd03fd6a2cf236682e5f5abd11232
+SHA1:
+  metadata.gz: d5590ab1d097eb650e1af98d2b913fc6f2b95287
+  data.tar.gz: 7ff2e0eb4c6dde13300166e9e18b512c5e01c6fa
 SHA512:
-  metadata.gz: 1ef7c3cea9a72c2fec7f87491c80eebc1aeeeca50c207fec4c713259a2de34c986a7a2457aed7cc20b36e4173f52fd9d30ac0340bca64600d23792d00433ac3f
-  data.tar.gz: 787c00650b5dd72258e895f51457599e0c20bd4d5897c5ec8c812fd4a54ce96796538b8c88cc689a02365f8fed5122237724a566aae9849dd5b807804a3a644f
+  metadata.gz: f372713523f16c4e281c7443c3f8f5bca116c392b93e3bea2df1f2ea823675f1330ef44d5b5f50ba6f21a991d972a1acc39483a36784fb77f0608b484cd24979
+  data.tar.gz: 99bfc3b3a4c2366a76bf0f94e019a37b564b8e06b54213746fa520e51af8d89cb2795e3dcc2eafb69fae0b59d2c4060bf505859591507719bae553d66cf8f04f

data/.travis.yml

@@ -1,10 +1,8 @@
 language: ruby
 rvm:
-  - 2.1.10
-  - 2.2.10
-  - 2.3.7
-  - 2.4.4
-  - 2.5.1
+  - 2.3
+  - 2.4
+  - 2.5
 branches:
   only:
     - master

data/docs/docker-imap.md

@@ -0,0 +1,18 @@
+# Access Docker imap server
+
+```ruby
+require "net/imap"
+
+imap = Net::IMAP.new("localhost", {port: 8993, ssl: {verify_mode: 0}})
+username = "address@example.org"
+imap.login(username, "pass")
+
+message = "From: #{username}\nSubject: Some Subject\n\nHello!\n"
+response = imap.append("INBOX", message, nil, nil)
+
+imap.examine("INBOX")
+uids = imap.uid_search(["ALL"]).sort
+
+REQUESTED_ATTRIBUTES = ["RFC822", "FLAGS", "INTERNALDATE"].freeze
+fetch_data_items = imap.uid_fetch(uids, REQUESTED_ATTRIBUTES)
+```

data/imap-backup.gemspec

@@ -13,6 +13,7 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^spec/})
   gem.require_paths = ["lib"]
+  gem.required_ruby_version = [">= 2.2.0"]
   gem.version       = Imap::Backup::VERSION
 
   gem.post_install_message = <<-MESSAGE.gsub(/^\s{4}/m, "")

data/lib/email/mboxrd/message.rb

@@ -27,6 +27,8 @@ module Email::Mboxrd
 
     def date
       parsed.date
+    rescue
+      nil
     end
 
     def imap_body

data/lib/imap/backup/account/folder.rb

@@ -67,7 +67,7 @@ module Imap::Backup
 
     def append(message)
       body = message.imap_body
-      date = message.date.to_time
+      date = message.date&.to_time
       response = imap.append(name, body, nil, date)
       extract_uid(response)
     end

data/lib/imap/backup/configuration/store.rb

@@ -76,7 +76,7 @@ module Imap::Backup
       if !File.directory?(path)
         FileUtils.mkdir path
       end
-      if Utils::stat(path) != 0o700
+      if Utils::mode(path) != 0o700
         FileUtils.chmod 0o700, path
       end
     end

data/lib/imap/backup/version.rb

@@ -4,6 +4,6 @@ module Imap::Backup
   MAJOR    = 2
   MINOR    = 0
   REVISION = 0
-  PRE      = "rc1"
+  PRE      = "rc2"
   VERSION  = [MAJOR, MINOR, REVISION, PRE].compact.map(&:to_s).join(".")
 end

data/spec/fixtures/connection.yml

@@ -2,5 +2,6 @@
 :username: 'address@example.org'
 :password: 'pass'
 :connection_options:
-  :port: 8143
-  :ssl: false
+  :port: 8993
+  :ssl:
+    :verify_mode: 0

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

@@ -30,6 +30,21 @@ describe Email::Mboxrd::Message do
   let(:cloned_message_body) do
     "Foo\nBar\nFrom at the beginning of the line\n>>From quoted"
   end
+  let(:msg_good) do
+    %Q|Delivered-To: you@example.com
+From: Foo <foo@example.com>
+To: FirstName LastName <you@example.com>
+Date: #{date.rfc822}
+Subject: Re: no subject|
+  end
+
+  let(:msg_bad_date) do
+    %Q|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|
+  end
 
   subject { described_class.new(message_body) }
 
@@ -90,14 +105,15 @@ describe Email::Mboxrd::Message do
       allow(Mail).to receive(:new).and_call_original
     end
 
-    context "when original message 'from' is nil" do
+    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 a string but not an address" do
+    context "when original message 'from' is a string but not well-formed address" do
       let(:message_body) { msg_bad_from }
 
       it "'from' is empty string" do
@@ -122,4 +138,20 @@ describe Email::Mboxrd::Message do
       end
     end
   end
+
+  context "#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
 end

data/spec/unit/{account → imap/backup/account}/connection_spec.rb

@@ -28,9 +28,21 @@ describe Imap::Backup::Account::Connection do
     instance_double(Net::IMAP::MailboxList, name: root_name)
   end
   let(:root_name) { "foo" }
+  let(:serializer) do
+    instance_double(
+      Imap::Backup::Serializer::Mbox,
+      folder: serialized_folder,
+      force_uid_validity: nil,
+      set_uid_validity: new_uid_validity,
+      uids: [local_uid]
+    )
+  end
+  let(:serialized_folder) { nil }
+  let(:new_uid_validity) { nil }
+  let(:local_uid) { "local_uid" }
 
   before do
-    allow(Net::IMAP).to receive(:new).and_return(imap)
+    allow(Net::IMAP).to receive(:new) { imap }
     allow(imap).to receive(:list).with("", "") { [root_info] }
     allow(imap).to receive(:list).with(root_name, "*") { imap_folders }
     allow(Imap::Backup::Utils).to receive(:make_folder)
@@ -89,10 +101,6 @@ describe Imap::Backup::Account::Connection do
     let(:folder) do
       instance_double(Imap::Backup::Account::Folder, uids: [remote_uid])
     end
-    let(:local_uid) { "local_uid" }
-    let(:serializer) do
-      instance_double(Imap::Backup::Serializer::Mbox, uids: [local_uid])
-    end
     let(:remote_uid) { "remote_uid" }
 
     before do
@@ -122,12 +130,6 @@ describe Imap::Backup::Account::Connection do
       )
     end
     let(:uid_validity) { 123 }
-    let(:serializer) do
-      instance_double(
-        Imap::Backup::Serializer::Mbox,
-        set_uid_validity: nil
-      )
-    end
     let(:downloader) { instance_double(Imap::Backup::Downloader, run: nil) }
 
     before do
@@ -193,13 +195,120 @@ describe Imap::Backup::Account::Connection do
     end
   end
 
+  context "#restore" do
+    let(:folder) do
+      instance_double(
+        Imap::Backup::Account::Folder,
+        create: nil,
+        exist?: exists,
+        name: "my_folder",
+        uid_validity: uid_validity
+      )
+    end
+    let(:exists) { true }
+    let(:uid_validity) { 123 }
+    let(:serialized_folder) { "old name" }
+    let(:uploader) do
+      instance_double(Imap::Backup::Uploader, run: false)
+    end
+    let(:updated_uploader) do
+      instance_double(Imap::Backup::Uploader, run: false)
+    end
+    let(:updated_folder) do
+      instance_double(
+        Imap::Backup::Account::Folder,
+        create: nil,
+        uid_validity: "new uid validity"
+      )
+    end
+    let(:updated_serializer) do
+      instance_double(
+        Imap::Backup::Serializer::Mbox, force_uid_validity: nil
+      )
+    end
+
+    before do
+      allow(Imap::Backup::Account::Folder).to receive(:new).
+        with(subject, "my_folder") { folder }
+      allow(Imap::Backup::Serializer::Mbox).to receive(:new).
+        with(anything, "my_folder") { serializer }
+      allow(Imap::Backup::Account::Folder).to receive(:new).
+        with(subject, "new name") { updated_folder }
+      allow(Imap::Backup::Serializer::Mbox).to receive(:new).
+        with(anything, "new name") { updated_serializer }
+      allow(Imap::Backup::Uploader).to receive(:new).
+        with(folder, serializer) { uploader }
+      allow(Imap::Backup::Uploader).to receive(:new).
+        with(updated_folder, updated_serializer) { updated_uploader }
+      allow(Pathname).to receive(:glob).
+        and_yield(Pathname.new(File.join(local_path, "my_folder.imap")))
+      subject.restore
+    end
+
+    it "sets local uid validity" do
+      expect(serializer).to have_received(:set_uid_validity).with(uid_validity)
+    end
+
+    context "when folders exist" do
+      context "when the local folder is renamed" do
+        let(:new_uid_validity) { "new name" }
+
+        it "creates the new folder" do
+          expect(updated_folder).to have_received(:create)
+        end
+
+        it "sets the renamed folder's uid validity" do
+          expect(updated_serializer).
+            to have_received(:force_uid_validity).with("new uid validity")
+        end
+
+        it "creates the uploader with updated folder and serializer" do
+          expect(updated_uploader).to have_received(:run)
+        end
+      end
+
+      context "when the local folder is not renamed" do
+        it "runs the uploader" do
+          expect(uploader).to have_received(:run)
+        end
+      end
+    end
+
+    context "when folders don't exist" do
+      let(:exists) { false }
+
+      it "creates the folder" do
+        expect(folder).to have_received(:create)
+      end
+
+      it "sets local uid validity" do
+      end
+
+      it "runs the uploader" do
+        expect(uploader).to have_received(:run)
+      end
+    end
+  end
+
+  context "#reconnect" do
+    before { subject.reconnect }
+
+    it "disconnects from the server" do
+      expect(imap).to have_received(:disconnect)
+    end
+
+    it "causes reconnection on future access" do
+      allow(Net::IMAP).to receive(:new) { imap }
+      subject.imap
+      expect(Net::IMAP).to have_received(:new).twice
+    end
+  end
+
   context "#disconnect" do
     before { subject.disconnect }
 
     it "disconnects from the server" do
       expect(imap).to have_received(:disconnect)
     end
-
-    include_examples "connects to IMAP"
   end
 end

data/spec/unit/imap/backup/account/folder_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+
+describe Imap::Backup::Account::Folder do
+  let(:imap) do
+    instance_double(
+      Net::IMAP,
+      append: append_response,
+      create: nil,
+      examine: nil,
+      responses: responses
+    )
+  end
+  let(:connection) { double("Imap::Backup::Account::Connection", imap: imap) }
+  let(:missing_mailbox_data) do
+    double("Data", text: "Unknown Mailbox: my_folder")
+  end
+  let(:missing_mailbox_response) do
+    double("Response", data: missing_mailbox_data)
+  end
+  let(:missing_mailbox_error) do
+    Net::IMAP::NoResponseError.new(missing_mailbox_response)
+  end
+  let(:responses) { [] }
+  let(:append_response) { nil }
+
+  subject { described_class.new(connection, "my_folder") }
+
+  context "#uids" do
+    let(:uids) { [5678, 123] }
+
+    before { allow(imap).to receive(:uid_search).and_return(uids) }
+
+    it "lists available messages" do
+      expect(subject.uids).to eq(uids.reverse)
+    end
+
+    context "with missing mailboxes" do
+      before do
+        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+      end
+
+      it "returns an empty array" do
+        expect(subject.uids).to eq([])
+      end
+    end
+  end
+
+  context "#fetch" do
+    let(:message_body) { double("the body", force_encoding: nil) }
+    let(:attributes) { {"RFC822" => message_body, "other" => "xxx"} }
+    let(:fetch_data_item) do
+      instance_double(Net::IMAP::FetchData, attr: attributes)
+    end
+
+    before { allow(imap).to receive(:uid_fetch) { [fetch_data_item] } }
+
+    it "returns the message" do
+      expect(subject.fetch(123)).to eq(attributes)
+    end
+
+    context "if the server responds with nothing" do
+      before { allow(imap).to receive(:uid_fetch) { nil } }
+
+      it "is nil" do
+        expect(subject.fetch(123)).to be_nil
+      end
+    end
+
+    context "if the mailbox doesn't exist" do
+      before do
+        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+      end
+
+      it "is nil" do
+        expect(subject.fetch(123)).to be_nil
+      end
+    end
+
+    it "sets the encoding on the message" do
+      subject.fetch(123)
+
+      expect(message_body).to have_received(:force_encoding).with("utf-8")
+    end
+  end
+
+  context "#folder"  do
+    it "is the name" do
+      expect(subject.folder).to eq("my_folder")
+    end
+  end
+
+  context "#exist?" do
+    context "when the folder exists" do
+      it "is true" do
+        expect(subject.exist?).to be_truthy
+      end
+    end
+
+    context "when the folder doesn't exist" do
+      before do
+        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+      end
+
+      it "is false" do
+        expect(subject.exist?).to be_falsey
+      end
+    end
+  end
+
+  context "#create" do
+    context "when the folder exists" do
+      before { subject.create }
+
+      it "is does not create the folder" do
+        expect(imap).to_not have_received(:create)
+      end
+    end
+
+    context "when the folder doesn't exist" do
+      before do
+        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        subject.create
+      end
+
+      it "is does not create the folder" do
+        expect(imap).to have_received(:create)
+      end
+    end
+  end
+
+  context "#uid_validity" do
+    let(:responses) { {"UIDVALIDITY" => ["x", "uid validity"]} }
+
+    it "is returned" do
+      expect(subject.uid_validity).to eq("uid validity")
+    end
+  end
+
+  context "#append" do
+    let(:message) do
+      instance_double(
+        Email::Mboxrd::Message,
+        imap_body: "imap body",
+        date: Time.now
+      )
+    end
+    let(:append_response) { "response" }
+    let(:result) { subject.append(message) }
+
+    before do
+      allow(append_response).
+        to receive_message_chain("data.code.data") { "1 2" }
+      result
+    end
+
+    it "appends the message" do
+      expect(imap).to have_received(:append)
+    end
+
+    it "returns the new uid" do
+      expect(result).to eq(2)
+    end
+
+    it "set the new uid validity" do
+      expect(subject.uid_validity).to eq(1)
+    end
+  end
+end

data/spec/unit/{configuration → imap/backup/configuration}/store_spec.rb

@@ -16,6 +16,7 @@ describe Imap::Backup::Configuration::Store do
       "Imap::Backup::Configuration::Store::CONFIGURATION_DIRECTORY", directory
     )
     allow(File).to receive(:directory?).with(directory) { directory_exists }
+    allow(File).to receive(:exist?).and_call_original
     allow(File).to receive(:exist?).with(file_path) { file_exists }
     allow(Imap::Backup::Utils).
       to receive(:stat).with(directory).and_return(0o700)

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

@@ -0,0 +1,164 @@
+describe Imap::Backup::Serializer::Mbox do
+  let(:base_path) { "/base/path" }
+  let(:store) do
+    instance_double(
+      Imap::Backup::Serializer::MboxStore,
+      add: nil,
+      rename: nil,
+      uids: nil,
+      uid_validity: existing_uid_validity,
+      "uid_validity=": nil
+    )
+  end
+  let(:imap_folder) { "folder" }
+  let(:permissions) { 0o700 }
+  let(:dir_exists) { true }
+  let(:existing_uid_validity) { nil }
+
+  before do
+    allow(Imap::Backup::Utils).to receive(:make_folder)
+    allow(Imap::Backup::Utils).to receive(:mode) { permissions }
+    allow(Imap::Backup::Utils).to receive(:check_permissions) { true }
+    allow(File).to receive(:directory?) { dir_exists }
+  end
+
+  subject { described_class.new(base_path, imap_folder) }
+
+  before do
+    allow(FileUtils).to receive(:chmod)
+    allow(Imap::Backup::Serializer::MboxStore).to receive(:new) { store }
+  end
+
+  context "containing directory" do
+    before { subject.uids }
+
+    context "when the IMAP folder has multiple elements" do
+      let(:imap_folder) { "folder/path" }
+
+      context "when the containing directory is missing" do
+        let(:dir_exists) { false }
+
+        it "is created" do
+          expect(Imap::Backup::Utils).to have_received(:make_folder).
+            with(base_path, File.dirname(imap_folder), 0o700)
+        end
+      end
+    end
+
+    context "when the containing directory permissons are incorrect" do
+      let(:permissions) { 0o777 }
+
+      it "corrects them" do
+        path = File.expand_path(File.join(base_path, File.dirname(imap_folder)))
+        expect(FileUtils).to have_received(:chmod).with(0o700, path)
+      end
+    end
+
+    context "when the containing directory permissons are correct" do
+      it "does nothing" do
+        expect(FileUtils).to_not have_received(:chmod)
+      end
+    end
+
+    context "when the containing directory exists" do
+      it "is not created" do
+        expect(Imap::Backup::Utils).to_not have_received(:make_folder).
+          with(base_path, File.dirname(imap_folder), 0o700)
+      end
+    end
+  end
+
+  context "#uids" do
+    it "calls the store" do
+      subject.uids
+
+      expect(store).to have_received(:uids)
+    end
+  end
+
+  context "#save" do
+    it "calls the store" do
+      subject.save("foo", "bar")
+
+      expect(store).to have_received(:add)
+    end
+  end
+
+  context "#set_uid_validity" do
+    let(:result) { subject.set_uid_validity("aaa") }
+
+    context "when the existing uid validity is unset" do
+      let!(:result) { super() }
+
+      it "sets uid validity" do
+        expect(store).to have_received(:uid_validity=).with("aaa")
+      end
+
+      it "does not rename the store" do
+        expect(store).to_not have_received(:rename)
+      end
+
+      it "returns nil" do
+        expect(result).to be_nil
+      end
+    end
+
+    context "when the uid validity is unchanged" do
+      let!(:result) { super() }
+      let(:existing_uid_validity) { "aaa" }
+
+      it "does not set uid validity" do
+        expect(store).to_not have_received(:uid_validity=)
+      end
+
+      it "does not rename the store" do
+        expect(store).to_not have_received(:rename)
+      end
+
+      it "returns nil" do
+        expect(result).to be_nil
+      end
+    end
+
+    context "when the uid validity is changed" do
+      let(:existing_uid_validity) { "bbb" }
+      let(:existing_store) do
+        instance_double(Imap::Backup::Serializer::MboxStore)
+      end
+      let(:exists) { false }
+
+      before do
+        allow(Imap::Backup::Serializer::MboxStore).
+          to receive(:new).with(anything, /bbb/) { existing_store }
+        allow(existing_store).to receive(:exist?).and_return(exists, false)
+        result
+      end
+
+      it "sets uid validity" do
+        expect(store).to have_received(:uid_validity=).with("aaa")
+      end
+
+      context "when adding the uid validity does not cause a name clash" do
+        it "renames the store, adding the existing uid validity" do
+          expect(store).to have_received(:rename).with("folder.bbb")
+        end
+
+        it "returns the new name" do
+          expect(result).to eq("folder.bbb")
+        end
+      end
+
+      context "when adding the uid validity causes a name clash" do
+        let(:exists) { true }
+
+        it "renames the store, adding the existing uid validity and a digit" do
+          expect(store).to have_received(:rename).with("folder.bbb.1")
+        end
+
+        it "returns the new name" do
+          expect(result).to eq("folder.bbb.1")
+        end
+      end
+    end
+  end
+end

data/spec/unit/imap/backup/uploader_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Imap::Backup::Uploader do
+  subject { described_class.new(folder, serializer) }
+
+  let(:folder) do
+    instance_double(Imap::Backup::Account::Folder, uids: [2, 3], append: 99)
+  end
+  let(:serializer) do
+    instance_double(
+      Imap::Backup::Serializer::Mbox,
+      uids: [1, 2],
+      update_uid: nil
+    )
+  end
+
+  describe "#run" do
+    before do
+      allow(serializer).to receive(:load).with(1) { "missing message" }
+      allow(serializer).to receive(:load).with(2) { "existing message" }
+      subject.run
+    end
+
+    context "with messages that are missing" do
+      it "restores them" do
+        expect(folder).to have_received(:append).with("missing message")
+      end
+
+      it "updates the local message id" do
+        expect(serializer).to have_received(:update_uid).with(1, 99)
+      end
+    end
+
+    context "with messages that are present on server" do
+      it "does nothing" do
+        expect(folder).to_not have_received(:append).with("existing message")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc2
 platform: ruby
 authors:
 - Joe Yates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-29 00:00:00.000000000 Z
+date: 2019-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -141,6 +141,7 @@ files:
 - Rakefile
 - bin/imap-backup
 - docker-compose.yml
+- docs/docker-imap.md
 - imap-backup.gemspec
 - lib/email/mboxrd/message.rb
 - lib/email/provider.rb
@@ -175,21 +176,22 @@ files:
 - spec/support/higline_test_helpers.rb
 - spec/support/shared_examples/account_flagging.rb
 - spec/support/silence_logging.rb
-- spec/unit/account/connection_spec.rb
-- spec/unit/account/folder_spec.rb
-- spec/unit/configuration/account_spec.rb
-- spec/unit/configuration/asker_spec.rb
-- spec/unit/configuration/connection_tester_spec.rb
-- spec/unit/configuration/folder_chooser_spec.rb
-- spec/unit/configuration/list_spec.rb
-- spec/unit/configuration/setup_spec.rb
-- spec/unit/configuration/store_spec.rb
-- spec/unit/downloader_spec.rb
 - spec/unit/email/mboxrd/message_spec.rb
 - spec/unit/email/provider_spec.rb
-- spec/unit/serializer/mbox_spec.rb
-- spec/unit/serializer/mbox_store_spec.rb
-- spec/unit/utils_spec.rb
+- spec/unit/imap/backup/account/connection_spec.rb
+- spec/unit/imap/backup/account/folder_spec.rb
+- spec/unit/imap/backup/configuration/account_spec.rb
+- spec/unit/imap/backup/configuration/asker_spec.rb
+- spec/unit/imap/backup/configuration/connection_tester_spec.rb
+- spec/unit/imap/backup/configuration/folder_chooser_spec.rb
+- spec/unit/imap/backup/configuration/list_spec.rb
+- spec/unit/imap/backup/configuration/setup_spec.rb
+- spec/unit/imap/backup/configuration/store_spec.rb
+- spec/unit/imap/backup/downloader_spec.rb
+- spec/unit/imap/backup/serializer/mbox_spec.rb
+- spec/unit/imap/backup/serializer/mbox_store_spec.rb
+- spec/unit/imap/backup/uploader_spec.rb
+- spec/unit/imap/backup/utils_spec.rb
 - tmp/.gitkeep
 homepage: https://github.com/joeyates/imap-backup
 licenses: []
@@ -206,7 +208,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
@@ -214,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Backup GMail (or other IMAP) accounts to disk
@@ -233,18 +235,19 @@ test_files:
 - spec/support/higline_test_helpers.rb
 - spec/support/shared_examples/account_flagging.rb
 - spec/support/silence_logging.rb
-- spec/unit/account/connection_spec.rb
-- spec/unit/account/folder_spec.rb
-- spec/unit/configuration/account_spec.rb
-- spec/unit/configuration/asker_spec.rb
-- spec/unit/configuration/connection_tester_spec.rb
-- spec/unit/configuration/folder_chooser_spec.rb
-- spec/unit/configuration/list_spec.rb
-- spec/unit/configuration/setup_spec.rb
-- spec/unit/configuration/store_spec.rb
-- spec/unit/downloader_spec.rb
 - spec/unit/email/mboxrd/message_spec.rb
 - spec/unit/email/provider_spec.rb
-- spec/unit/serializer/mbox_spec.rb
-- spec/unit/serializer/mbox_store_spec.rb
-- spec/unit/utils_spec.rb
+- spec/unit/imap/backup/account/connection_spec.rb
+- spec/unit/imap/backup/account/folder_spec.rb
+- spec/unit/imap/backup/configuration/account_spec.rb
+- spec/unit/imap/backup/configuration/asker_spec.rb
+- spec/unit/imap/backup/configuration/connection_tester_spec.rb
+- spec/unit/imap/backup/configuration/folder_chooser_spec.rb
+- spec/unit/imap/backup/configuration/list_spec.rb
+- spec/unit/imap/backup/configuration/setup_spec.rb
+- spec/unit/imap/backup/configuration/store_spec.rb
+- spec/unit/imap/backup/downloader_spec.rb
+- spec/unit/imap/backup/serializer/mbox_spec.rb
+- spec/unit/imap/backup/serializer/mbox_store_spec.rb
+- spec/unit/imap/backup/uploader_spec.rb
+- spec/unit/imap/backup/utils_spec.rb

data/spec/unit/account/folder_spec.rb

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-describe Imap::Backup::Account::Folder do
-  let(:imap) { double("Net::IMAP", examine: nil) }
-  let(:connection) { double("Imap::Backup::Account::Connection", imap: imap) }
-  let(:missing_mailbox_data) do
-    double("Data", text: "Unknown Mailbox: my_folder")
-  end
-  let(:missing_mailbox_response) do
-    double("Response", data: missing_mailbox_data)
-  end
-  let(:missing_mailbox_error) do
-    Net::IMAP::NoResponseError.new(missing_mailbox_response)
-  end
-
-  subject { described_class.new(connection, "my_folder") }
-
-  context "#uids" do
-    let(:uids) { [5678, 123] }
-
-    before { allow(imap).to receive(:uid_search).and_return(uids) }
-
-    it "lists available messages" do
-      expect(subject.uids).to eq(uids.reverse)
-    end
-
-    context "with missing mailboxes" do
-      before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
-      end
-
-      it "returns an empty array" do
-        expect(subject.uids).to eq([])
-      end
-    end
-  end
-
-  context "#fetch" do
-    let(:message_body) { double("the body", force_encoding: nil) }
-    let(:attributes) { {"RFC822" => message_body, "other" => "xxx"} }
-    let(:fetch_data_item) do
-      instance_double(Net::IMAP::FetchData, attr: attributes)
-    end
-
-    before { allow(imap).to receive(:uid_fetch) { [fetch_data_item] } }
-
-    it "returns the message" do
-      expect(subject.fetch(123)).to eq(attributes)
-    end
-
-    context "if the server responds with nothing" do
-      before { allow(imap).to receive(:uid_fetch) { nil } }
-
-      it "is nil" do
-        expect(subject.fetch(123)).to be_nil
-      end
-    end
-
-    context "if the mailbox doesn't exist" do
-      before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
-      end
-
-      it "is nil" do
-        expect(subject.fetch(123)).to be_nil
-      end
-    end
-
-    it "sets the encoding on the message" do
-      subject.fetch(123)
-
-      expect(message_body).to have_received(:force_encoding).with("utf-8")
-    end
-  end
-end

data/spec/unit/serializer/mbox_spec.rb

@@ -1,82 +0,0 @@
-describe Imap::Backup::Serializer::Mbox do
-  let(:base_path) { "/base/path" }
-  let(:store) do
-    instance_double(
-      Imap::Backup::Serializer::MboxStore,
-      add: nil,
-      uids: nil
-    )
-  end
-  let(:imap_folder) { "folder" }
-  let(:permissions) { 0o700 }
-  let(:dir_exists) { true }
-
-  before do
-    allow(Imap::Backup::Utils).to receive(:make_folder)
-    allow(Imap::Backup::Utils).to receive(:mode) { permissions }
-    allow(Imap::Backup::Utils).to receive(:check_permissions) { true }
-    allow(File).to receive(:directory?) { dir_exists }
-  end
-
-  subject { described_class.new(base_path, imap_folder) }
-
-  before do
-    allow(FileUtils).to receive(:chmod)
-    allow(Imap::Backup::Serializer::MboxStore).to receive(:new) { store }
-  end
-
-  context "containing directory" do
-    before { subject.uids }
-
-    context "when the IMAP folder has multiple elements" do
-      let(:imap_folder) { "folder/path" }
-
-      context "when the containing directory is missing" do
-        let(:dir_exists) { false }
-
-        it "is created" do
-          expect(Imap::Backup::Utils).to have_received(:make_folder).
-            with(base_path, File.dirname(imap_folder), 0o700)
-        end
-      end
-    end
-
-    context "when the containing directory permissons are incorrect" do
-      let(:permissions) { 0o777 }
-
-      it "corrects them" do
-        path = File.expand_path(File.join(base_path, File.dirname(imap_folder)))
-        expect(FileUtils).to have_received(:chmod).with(0o700, path)
-      end
-    end
-
-    context "when the containing directory permissons are correct" do
-      it "does nothing" do
-        expect(FileUtils).to_not have_received(:chmod)
-      end
-    end
-
-    context "when the containing directory exists" do
-      it "is not created" do
-        expect(Imap::Backup::Utils).to_not have_received(:make_folder).
-          with(base_path, File.dirname(imap_folder), 0o700)
-      end
-    end
-  end
-
-  context "#uids" do
-    it "calls the store" do
-      subject.uids
-
-      expect(store).to have_received(:uids)
-    end
-  end
-
-  context "#save" do
-    it "calls the store" do
-      subject.save("foo", "bar")
-
-      expect(store).to have_received(:add)
-    end
-  end
-end