imap-backup 3.0.0 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e4037b31fc56dcf88f312506ff2814b1c3fb516ae13cf9dbb4c8a772928b5fa
-  data.tar.gz: 0465b9bf0b7a6a9dadc5c6c35b1a4dd65db058ab1ed37158d9fedf2dc093f777
+  metadata.gz: c3446b53604f5895cb09b109cbe663bc4ac131daeb63989b09ae8985c480464b
+  data.tar.gz: 8c3b6a7176dbda814f208505c49ed63f27d650f683dad7941734e8dbd4018601
 SHA512:
-  metadata.gz: 459620b79228707291d0b3be5037830e7100da42ecc920a1b5e19797fd1cc9aa9bc8fa667f5a5a7f89cc5d2647f47df5ae7e384a575c62a9bf4a13c25c70dd4b
-  data.tar.gz: 8ac9d67819df8f957ffbc6a93be59aa401bdec704d75fa637c186012d2f15e23c3efa5c68ca8dc8918c97de3d90623ee5627d3cb8107615ee108e76588afd054
+  metadata.gz: 6926f54cb421029116f0e63533e1a3c3151937c9572b2c5b2143cab08e3c1aef81cba6ae3dcc2c799f77e37f3b983c4adee73f6fa90f585cddf030cff8fffd9d
+  data.tar.gz: 1ed5e647c1ef08049f928293295cb564d7e87b592dd499dc903bab74717892fffc2aa19d4f214824757dcb80f46356c12864a7cf8332b3f25512c1af637f1aff

data/.circleci/config.yml

@@ -0,0 +1,51 @@
+version: 2.1
+
+orbs:
+  ruby: circleci/ruby@1.1.2
+
+references:
+  restore: &restore
+    restore_cache:
+      keys:
+        - 'imap.backup.<< parameters.ruby_version >>.{{checksum "imap-backup.gemspec"}}'
+  bundle: &bundle
+    run:
+      name: Install Ruby dependencies
+      command: |
+        bundle install
+        bundle clean
+  save: &save
+    save_cache:
+      key: 'imap.backup.<< parameters.ruby_version >>.{{checksum "imap-backup.gemspec"}}'
+      paths:
+        - vendor/bundle
+
+jobs:
+  test:
+    parameters:
+      ruby_version:
+        type: string
+    environment:
+      BUNDLE_PATH: ./vendor/bundle
+      DOCKER_IMAP_PORT: 993
+    docker:
+      - image: "cimg/ruby:<< parameters.ruby_version >>"
+      - image: antespi/docker-imap-devel:latest
+        environment:
+          MAIL_ADDRESS: address@example.org
+          MAIL_PASS: pass
+          MAILNAME: example.org
+    steps:
+      - checkout
+      - <<: *restore
+      - <<: *bundle
+      - <<: *save
+      - ruby/rspec-test
+
+workflows:
+  all-tests:
+    jobs:
+      - test:
+          matrix:
+            parameters:
+              ruby_version: ["2.4", "2.5", "2.6", "2.7"]

data/README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://secure.travis-ci.org/joeyates/imap-backup.svg)][Continuous Integration]
+[![Build Status](https://circleci.com/gh/joeyates/imap-backup.svg?style=svg)][Continuous Integration]
 [![Source Analysis](https://codeclimate.com/github/joeyates/imap-backup/badges/gpa.svg)](https://codeclimate.com/github/joeyates/imap-backup)
 [![Test Coverage](https://codeclimate.com/github/joeyates/imap-backup/badges/coverage.svg)](https://codeclimate.com/github/joeyates/imap-backup/coverage)
 
@@ -14,7 +14,7 @@
 [Source Code]: https://github.com/joeyates/imap-backup "Source code at GitHub"
 [API documentation]: http://rubydoc.info/gems/imap-backup/frames "RDoc API Documentation at Rubydoc.info"
 [Rubygem]: http://rubygems.org/gems/imap-backup "Ruby gem at rubygems.org"
-[Continuous Integration]: http://travis-ci.org/joeyates/imap-backup "Build status by Travis-CI"
+[Continuous Integration]: https://circleci.com/gh/joeyates/imap-backup "Build status by CirceCI"
 
 ## GMail
 
@@ -212,6 +212,12 @@ $ rake
 
 To exclude Docker-based tests:
 
+```sh
+rake no-docker
+```
+
+or
+
 ```sh
 $ rspec --tag ~docker
 ```

data/Rakefile

@@ -6,6 +6,12 @@ RSpec::Core::RakeTask.new do |t|
   t.pattern = "spec/**/*_spec.rb"
 end
 
+desc "Run RSpec examples, excluding ones relying on Docker IMAP"
+RSpec::Core::RakeTask.new("no-docker") do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.rspec_opts = "--tag ~docker"
+end
+
 RuboCop::RakeTask.new
 
 task default: :spec

data/bin/imap-backup

@@ -82,7 +82,7 @@ when "folders"
       warn "Unable to list account folders"
       exit 1
     end
-    folders.each { |f| puts "\t#{f.name}" }
+    folders.each { |f| puts "\t#{f}" }
   end
 when "restore"
   configuration.each_connection(&:restore)

data/imap-backup.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |gem|
     gem.add_development_dependency "pry-byebug"
   end
   gem.add_development_dependency "rspec", ">= 3.0.0"
+  gem.add_development_dependency "rspec_junit_formatter"
   gem.add_development_dependency "rubocop-rspec"
   gem.add_development_dependency "simplecov"
 end

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

@@ -2,6 +2,7 @@ require "net/imap"
 require "gmail_xoauth"
 
 require "gmail/authenticator"
+require "retry_on_error"
 
 module Imap::Backup
   module Account; end
@@ -9,6 +10,10 @@ module Imap::Backup
   class Account::Connection
     class InvalidGmailOauth2RefreshToken < StandardError; end
 
+    include RetryOnError
+
+    LOGIN_RETRY_CLASSES = [EOFError, Errno::ECONNRESET, SocketError].freeze
+
     attr_reader :connection_options
     attr_reader :local_path
     attr_reader :password
@@ -18,7 +23,7 @@ module Imap::Backup
       @username = options[:username]
       @password = options[:password]
       @local_path = options[:local_path]
-      @backup_folders = options[:folders]
+      @config_folders = options[:folders]
       @server = options[:server]
       @connection_options = options[:connection_options] || {}
       @folders = nil
@@ -29,21 +34,24 @@ module Imap::Backup
       @folders ||=
         begin
           root = provider_root
-          @folders = imap.list(root, "*")
-          if @folders.nil?
-            Imap::Backup.logger.warn(
-              "Unable to get folder list for account #{username}"
-            )
+          mailbox_lists = imap.list(root, "*")
+
+          if mailbox_lists.nil?
+            message = "Unable to get folder list for account #{username}"
+            Imap::Backup.logger.info message
+            raise message
           end
-          @folders
+
+          utf7_encoded = mailbox_lists.map(&:name)
+          utf7_encoded.map { |n| Net::IMAP.decode_utf7(n) }
         end
     end
 
     def status
-      backup_folders.map do |folder|
-        f = Account::Folder.new(self, folder[:name])
-        s = Serializer::Mbox.new(local_path, folder[:name])
-        {name: folder[:name], local: s.uids, remote: f.uids}
+      backup_folders.map do |backup_folder|
+        f = Account::Folder.new(self, backup_folder[:name])
+        s = Serializer::Mbox.new(local_path, backup_folder[:name])
+        {name: backup_folder[:name], local: s.uids, remote: f.uids}
       end
     end
 
@@ -56,7 +64,12 @@ module Imap::Backup
 
         Imap::Backup.logger.debug "[#{folder.name}] running backup"
         serializer.apply_uid_validity(folder.uid_validity)
-        Downloader.new(folder, serializer).run
+        begin
+          Downloader.new(folder, serializer).run
+        rescue Net::IMAP::ByeResponseError
+          reconnect
+          retry
+        end
       end
     end
 
@@ -76,26 +89,27 @@ module Imap::Backup
     end
 
     def imap
-      return @imap unless @imap.nil?
-
-      options = provider_options
-      Imap::Backup.logger.debug(
-        "Creating IMAP instance: #{server}, options: #{options.inspect}"
-      )
-      @imap = Net::IMAP.new(server, options)
-      if gmail? && Gmail::Authenticator.refresh_token?(password)
-        authenticator = Gmail::Authenticator.new(email: username, token: password)
-        credentials = authenticator.credentials
-        raise InvalidGmailOauth2RefreshToken if !credentials
-
-        Imap::Backup.logger.debug "Logging in with OAuth2 token: #{username}"
-        @imap.authenticate("XOAUTH2", username, credentials.access_token)
-      else
-        Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
-        @imap.login(username, password)
-      end
-      Imap::Backup.logger.debug "Login complete"
-      @imap
+      @imap ||=
+        retry_on_error(errors: LOGIN_RETRY_CLASSES) do
+          options = provider_options
+          Imap::Backup.logger.debug(
+            "Creating IMAP instance: #{server}, options: #{options.inspect}"
+          )
+          imap = Net::IMAP.new(server, options)
+          if gmail? && Gmail::Authenticator.refresh_token?(password)
+            authenticator = Gmail::Authenticator.new(email: username, token: password)
+            credentials = authenticator.credentials
+            raise InvalidGmailOauth2RefreshToken if !credentials
+
+            Imap::Backup.logger.debug "Logging in with OAuth2 token: #{username}"
+            imap.authenticate("XOAUTH2", username, credentials.access_token)
+          else
+            Imap::Backup.logger.debug "Logging in: #{username}/#{masked_password}"
+            imap.login(username, password)
+          end
+          Imap::Backup.logger.debug "Login complete"
+          imap
+        end
     end
 
     def server
@@ -105,18 +119,12 @@ module Imap::Backup
       @server = provider.host
     end
 
-    def backup_folders
-      return @backup_folders if @backup_folders && !@backup_folders.empty?
-
-      (folders || []).map { |f| {name: f.name} }
-    end
-
     private
 
     def each_folder
-      backup_folders.each do |folder_info|
-        folder = Account::Folder.new(self, folder_info[:name])
-        serializer = Serializer::Mbox.new(local_path, folder_info[:name])
+      backup_folders.each do |backup_folder|
+        folder = Account::Folder.new(self, backup_folder[:name])
+        serializer = Serializer::Mbox.new(local_path, backup_folder[:name])
         yield folder, serializer
       end
     end
@@ -175,6 +183,17 @@ module Imap::Backup
       end
     end
 
+    def backup_folders
+      @backup_folders ||=
+        begin
+          if @config_folders&.any?
+            @config_folders
+          else
+            folders.map { |name| {name: name} }
+          end
+        end
+    end
+
     def provider
       @provider ||= Email::Provider.for_address(username)
     end

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

@@ -1,5 +1,7 @@
 require "forwardable"
 
+require "retry_on_error"
+
 module Imap::Backup
   module Account; end
 
@@ -7,8 +9,10 @@ module Imap::Backup
 
   class Account::Folder
     extend Forwardable
+    include RetryOnError
 
     REQUESTED_ATTRIBUTES = %w[RFC822 FLAGS INTERNALDATE].freeze
+    UID_FETCH_RETRY_CLASSES = [EOFError].freeze
 
     attr_reader :connection
     attr_reader :name
@@ -36,7 +40,7 @@ module Imap::Backup
     def create
       return if exist?
 
-      imap.create(name)
+      imap.create(utf7_encoded_name)
     end
 
     def uid_validity
@@ -66,7 +70,10 @@ module Imap::Backup
 
     def fetch(uid)
       examine
-      fetch_data_items = imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
+      fetch_data_items =
+        retry_on_error(errors: UID_FETCH_RETRY_CLASSES) do
+          imap.uid_fetch([uid.to_i], REQUESTED_ATTRIBUTES)
+        end
       return nil if fetch_data_items.nil?
 
       fetch_data_item = fetch_data_items[0]
@@ -81,22 +88,27 @@ module Imap::Backup
     def append(message)
       body = message.imap_body
       date = message.date&.to_time
-      response = imap.append(name, body, nil, date)
+      response = imap.append(utf7_encoded_name, body, nil, date)
       extract_uid(response)
     end
 
     private
 
     def examine
-      imap.examine(name)
+      imap.examine(utf7_encoded_name)
     rescue Net::IMAP::NoResponseError
-      Imap::Backup.logger.warn "Folder '#{name}' does not exist"
-      raise FolderNotFound, "Folder '#{name}' does not exist"
+      Imap::Backup.logger.warn "Folder '#{name}' does not exist on server"
+      raise FolderNotFound, "Folder '#{name}' does not exist on server"
     end
 
     def extract_uid(response)
       @uid_validity, uid = response.data.code.data.split(" ").map(&:to_i)
       uid
     end
+
+    def utf7_encoded_name
+      @utf7_encoded_name ||=
+        Net::IMAP.encode_utf7(name).force_encoding("ASCII-8BIT")
+    end
   end
 end

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

@@ -15,7 +15,7 @@ module Imap::Backup
         return
       end
 
-      if folders.nil?
+      if imap_folders.nil?
         Imap::Backup.logger.warn "Unable to get folder list"
         highline.ask "Press a key "
         return
@@ -44,29 +44,28 @@ module Imap::Backup
     end
 
     def add_folders(menu)
-      folders.each do |folder|
-        name = folder.name
-        mark = selected?(name) ? "+" : "-"
-        menu.choice("#{mark} #{name}") do
-          toggle_selection name
+      imap_folders.each do |folder|
+        mark = selected?(folder) ? "+" : "-"
+        menu.choice("#{mark} #{folder}") do
+          toggle_selection folder
         end
       end
     end
 
     def selected?(folder_name)
-      backup_folders = account[:folders]
-      return false if backup_folders.nil?
+      config_folders = account[:folders]
+      return false if config_folders.nil?
 
-      backup_folders.find { |f| f[:name] == folder_name }
+      config_folders.find { |f| f[:name] == folder_name }
     end
 
     def remove_missing
       removed = []
-      backup_folders = []
+      config_folders = []
       account[:folders].each do |f|
-        found = folders.find { |folder| folder.name == f[:name] }
+        found = imap_folders.find { |folder| folder == f[:name] }
         if found
-          backup_folders << f
+          config_folders << f
         else
           removed << f[:name]
         end
@@ -74,7 +73,7 @@ module Imap::Backup
 
       return if removed.empty?
 
-      account[:folders] = backup_folders
+      account[:folders] = config_folders
       account[:modified] = true
 
       Kernel.puts <<~MESSAGE
@@ -101,8 +100,8 @@ module Imap::Backup
       nil
     end
 
-    def folders
-      @folders ||= connection.folders
+    def imap_folders
+      @imap_folders ||= connection.folders
     end
 
     def highline

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

@@ -8,7 +8,7 @@ module Imap::Backup
       You need to authorize imap_backup to get access to your email.
       To do so, please follow the instructions here:
 
-      https://github.com/joeyates/imap-backup/docs/setting-up-gmail.md
+      https://github.com/joeyates/imap-backup/blob/main/docs/setting-up-gmail.md
 
     BANNER
 
@@ -26,8 +26,20 @@ module Imap::Backup
     def run
       Kernel.system("clear")
       Kernel.puts BANNER
-      @client_id = highline.ask("client_id: ")
-      @client_secret = highline.ask("client_secret: ")
+
+      keep = if token.valid?
+        highline.agree("Use existing client info?")
+      else
+        false
+      end
+
+      if keep
+        @client_id = token.client_id
+        @client_secret = token.client_secret
+      else
+        @client_id = highline.ask("client_id: ")
+        @client_secret = highline.ask("client_secret: ")
+      end
 
       Kernel.puts <<~MESSAGE
 
@@ -46,9 +58,9 @@ module Imap::Backup
 
       raise "Failed" if !@credentials
 
-      token = JSON.parse(token_store.load(email))
-      token["client_secret"] = client_secret
-      token.to_json
+      new_token = JSON.parse(token_store.load(email))
+      new_token["client_secret"] = client_secret
+      new_token.to_json
     end
 
     private
@@ -57,6 +69,14 @@ module Imap::Backup
       account[:username]
     end
 
+    def password
+      account[:password]
+    end
+
+    def token
+      @token ||= Gmail::Authenticator::ImapBackupToken.new(password)
+    end
+
     def highline
       Configuration::Setup.highline
     end

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

@@ -51,18 +51,18 @@ module Imap::Backup
     private
 
     def data
-      return @data if @data
-
-      if File.exist?(pathname)
-        Utils.check_permissions pathname, 0o600
-        contents = File.read(pathname)
-        @data = JSON.parse(contents, symbolize_names: true)
-      else
-        @data = {accounts: []}
-      end
-      @data[:debug] = false unless @data.include?(:debug)
-      @data[:debug] = false unless [true, false].include?(@data[:debug])
-      @data
+      @data ||=
+        begin
+          if File.exist?(pathname)
+            Utils.check_permissions pathname, 0o600
+            contents = File.read(pathname)
+            data = JSON.parse(contents, symbolize_names: true)
+          else
+            data = {accounts: []}
+          end
+          data[:debug] = data.key?(:debug) ? data[:debug] == true : false
+          data
+        end
     end
 
     def remove_modified_flags

data/lib/imap/backup/serializer/mbox_store.rb

@@ -161,7 +161,7 @@ module Imap::Backup
     def load_nth(index)
       enumerator = Serializer::MboxEnumerator.new(mbox_pathname)
       enumerator.each.with_index do |raw, i|
-        next unless i == index
+        next if i != index
 
         return Email::Mboxrd::Message.from_serialized(raw)
       end
@@ -169,7 +169,7 @@ module Imap::Backup
     end
 
     def imap_looks_like_json?
-      return false unless imap_exist?
+      return false if !imap_exist?
 
       content = File.read(imap_pathname)
       content.start_with?("{")

data/lib/imap/backup/version.rb

@@ -2,8 +2,8 @@ module Imap; end
 
 module Imap::Backup
   MAJOR    = 3
-  MINOR    = 0
-  REVISION = 0
+  MINOR    = 3
+  REVISION = 1
   PRE      = nil
   VERSION  = [MAJOR, MINOR, REVISION, PRE].compact.map(&:to_s).join(".")
 end

data/lib/retry_on_error.rb

@@ -0,0 +1,14 @@
+module RetryOnError
+  def retry_on_error(errors:, limit: 10)
+    tries ||= 1
+    yield
+  rescue *errors => e
+    if tries < limit
+      message = "#{e}, attempt #{tries} of #{limit}"
+      Imap::Backup.logger.debug message
+      tries += 1
+      retry
+    end
+    raise e
+  end
+end

data/spec/fixtures/connection.yml

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

data/spec/support/fixtures.rb

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

data/spec/unit/gmail/authenticator_spec.rb

@@ -85,7 +85,7 @@ describe Gmail::Authenticator do
 
         it "is expected" do
           expect { subject }.to raise_error(
-            ArgumentError, /missing keyword: :#{param}/
+            ArgumentError, /missing keyword: :?#{param}/
           )
         end
       end

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

@@ -23,11 +23,11 @@ describe Imap::Backup::Account::Connection do
       username: USERNAME,
       password: PASSWORD,
       local_path: LOCAL_PATH,
-      folders: backup_folders,
+      folders: config_folders,
       server: server
     }
   end
-  let(:backup_folders) { [FOLDER_CONFIG] }
+  let(:config_folders) { [FOLDER_CONFIG] }
   let(:root_info) do
     instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)
   end
@@ -62,7 +62,6 @@ describe Imap::Backup::Account::Connection do
       [:username, USERNAME],
       [:password, PASSWORD],
       [:local_path, LOCAL_PATH],
-      [:backup_folders, [FOLDER_CONFIG]],
       [:server, SERVER]
     ].each do |attr, expected|
       it "expects #{attr}" do
@@ -78,13 +77,15 @@ describe Imap::Backup::Account::Connection do
   end
 
   describe "#imap" do
-    let!(:result) { subject.imap }
+    let(:result) { subject.imap }
 
     it "returns the IMAP connection" do
       expect(result).to eq(imap)
     end
 
     it "uses the password" do
+      result
+
       expect(imap).to have_received(:login).with(USERNAME, PASSWORD)
     end
 
@@ -139,16 +140,43 @@ describe Imap::Backup::Account::Connection do
       end
     end
 
-    include_examples "connects to IMAP"
+    context "when the first login attempt fails" do
+      before do
+        outcomes = [-> { raise EOFError }, -> { true }]
+        allow(imap).to receive(:login) { outcomes.shift.call }
+      end
+
+      it "retries" do
+        subject.imap
+
+        expect(imap).to have_received(:login).twice
+      end
+    end
+
+    context "when run" do
+      before { subject.imap }
+
+      include_examples "connects to IMAP"
+    end
   end
 
   describe "#folders" do
     let(:imap_folders) do
-      [instance_double(Net::IMAP::MailboxList)]
+      [instance_double(Net::IMAP::MailboxList, name: BACKUP_FOLDER)]
     end
 
     it "returns the list of folders" do
-      expect(subject.folders).to eq(imap_folders)
+      expect(subject.folders).to eq([BACKUP_FOLDER])
+    end
+
+    context "with non-ASCII folder names" do
+      let(:imap_folders) do
+        [instance_double(Net::IMAP::MailboxList, name: "Gel&APY-scht")]
+      end
+
+      it "converts them to UTF-8" do
+        expect(subject.folders).to eq(["Gelöscht"])
+      end
     end
   end
 
@@ -198,7 +226,7 @@ describe Imap::Backup::Account::Connection do
         with(LOCAL_PATH, BACKUP_FOLDER) { serializer }
     end
 
-    context "with supplied backup_folders" do
+    context "with supplied config_folders" do
       it "runs the downloader" do
         expect(downloader).to receive(:run)
 
@@ -216,7 +244,7 @@ describe Imap::Backup::Account::Connection do
       end
     end
 
-    context "without supplied backup_folders" do
+    context "without supplied config_folders" do
       let(:imap_folders) do
         [instance_double(Net::IMAP::MailboxList, name: ROOT_NAME)]
       end
@@ -228,8 +256,8 @@ describe Imap::Backup::Account::Connection do
           with(LOCAL_PATH, ROOT_NAME) { serializer }
       end
 
-      context "when supplied backup_folders is nil" do
-        let(:backup_folders) { nil }
+      context "when supplied config_folders is nil" do
+        let(:config_folders) { nil }
 
         it "runs the downloader for each folder" do
           expect(downloader).to receive(:run).exactly(:once)
@@ -238,8 +266,8 @@ describe Imap::Backup::Account::Connection do
         end
       end
 
-      context "when supplied backup_folders is an empty list" do
-        let(:backup_folders) { [] }
+      context "when supplied config_folders is an empty list" do
+        let(:config_folders) { [] }
 
         it "runs the downloader for each folder" do
           expect(downloader).to receive(:run).exactly(:once)
@@ -249,15 +277,35 @@ describe Imap::Backup::Account::Connection do
       end
 
       context "when the imap server doesn't return folders" do
-        let(:backup_folders) { nil }
+        let(:config_folders) { nil }
         let(:imap_folders) { nil }
 
-        it "does not fail" do
-          expect { subject.run_backup }.to_not raise_error
+        it "fails" do
+          expect do
+            subject.run_backup
+          end.to raise_error(RuntimeError, /Unable to get folder list/)
         end
       end
     end
 
+    context "when the IMAP session expires" do
+      before do
+        data = OpenStruct.new(data: "Session expired")
+        response = OpenStruct.new(data: data)
+        outcomes = [
+          -> { raise Net::IMAP::ByeResponseError, response },
+          -> { nil }
+        ]
+        allow(downloader).to receive(:run) { outcomes.shift.call }
+      end
+
+      it "reconnects" do
+        expect(downloader).to receive(:run).exactly(:twice)
+
+        subject.run_backup
+      end
+    end
+
     context "when run" do
       before { subject.run_backup }
 

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

@@ -1,7 +1,10 @@
 # rubocop:disable RSpec/PredicateMatcher
 
 describe Imap::Backup::Account::Folder do
-  subject { described_class.new(connection, "my_folder") }
+  FOLDER_NAME = "Gelöscht".freeze
+  ENCODED_FOLDER_NAME = "Gel&APY-scht".freeze
+
+  subject { described_class.new(connection, FOLDER_NAME) }
 
   let(:imap) do
     instance_double(
@@ -16,7 +19,7 @@ describe Imap::Backup::Account::Folder do
     instance_double(Imap::Backup::Account::Connection, imap: imap)
   end
   let(:missing_mailbox_data) do
-    OpenStruct.new(text: "Unknown Mailbox: my_folder")
+    OpenStruct.new(text: "Unknown Mailbox: #{FOLDER_NAME}")
   end
   let(:missing_mailbox_response) { OpenStruct.new(data: missing_mailbox_data) }
   let(:missing_mailbox_error) do
@@ -36,7 +39,8 @@ describe Imap::Backup::Account::Folder do
 
     context "with missing mailboxes" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "returns an empty array" do
@@ -50,7 +54,8 @@ describe Imap::Backup::Account::Folder do
       end
 
       before do
-        allow(imap).to receive(:examine).and_raise(no_method_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "returns an empty array" do
@@ -82,7 +87,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the mailbox doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "is nil" do
@@ -97,11 +103,28 @@ describe Imap::Backup::Account::Folder do
         expect(subject.fetch(123)).to be_nil
       end
     end
+
+    context "when the first fetch_uid attempts fail" do
+      before do
+        outcomes = [-> { raise EOFError }, -> { [fetch_data_item] }]
+        allow(imap).to receive(:uid_fetch) { outcomes.shift.call }
+      end
+
+      it "retries" do
+        subject.fetch(123)
+
+        expect(imap).to have_received(:uid_fetch).twice
+      end
+
+      it "succeeds" do
+        subject.fetch(123)
+      end
+    end
   end
 
   describe "#folder" do
     it "is the name" do
-      expect(subject.folder).to eq("my_folder")
+      expect(subject.folder).to eq(FOLDER_NAME)
     end
   end
 
@@ -114,7 +137,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "is false" do
@@ -134,14 +158,21 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
-      it "is does not create the folder" do
+      it "creates the folder" do
         expect(imap).to receive(:create)
 
         subject.create
       end
+
+      it "encodes the folder name" do
+        expect(imap).to receive(:create).with(ENCODED_FOLDER_NAME)
+
+        subject.create
+      end
     end
   end
 
@@ -154,7 +185,8 @@ describe Imap::Backup::Account::Folder do
 
     context "when the folder doesn't exist" do
       before do
-        allow(imap).to receive(:examine).and_raise(missing_mailbox_error)
+        allow(imap).to receive(:examine).
+          with(ENCODED_FOLDER_NAME).and_raise(missing_mailbox_error)
       end
 
       it "raises an error" do

data/spec/unit/imap/backup/configuration/folder_chooser_spec.rb

@@ -6,11 +6,11 @@ describe Imap::Backup::Configuration::FolderChooser do
 
     let(:connection) do
       instance_double(
-        Imap::Backup::Account::Connection, folders: remote_folders
+        Imap::Backup::Account::Connection, folders: connection_folders
       )
     end
     let(:account) { {folders: []} }
-    let(:remote_folders) { [] }
+    let(:connection_folders) { [] }
     let!(:highline_streams) { prepare_highline }
     let(:input) { highline_streams[0] }
     let(:output) { highline_streams[1] }
@@ -37,15 +37,9 @@ describe Imap::Backup::Configuration::FolderChooser do
 
     describe "folder listing" do
       let(:account) { {folders: [{name: "my_folder"}]} }
-      let(:remote_folders) do
-        # this one is already backed up:
-        folder1 = instance_double(
-          Imap::Backup::Account::Folder, name: "my_folder"
-        )
-        folder2 = instance_double(
-          Imap::Backup::Account::Folder, name: "another_folder"
-        )
-        [folder1, folder2]
+      let(:connection_folders) do
+        # N.B. my_folder is already backed up
+        %w(my_folder another_folder)
       end
 
       describe "display" do
@@ -93,7 +87,7 @@ describe Imap::Backup::Configuration::FolderChooser do
       let(:account) do
         {folders: [{name: "on_server"}, {name: "not_on_server"}]}
       end
-      let(:remote_folders) do
+      let(:connection_folders) do
         [
           instance_double(Imap::Backup::Account::Folder, name: "on_server")
         ]
@@ -112,7 +106,7 @@ describe Imap::Backup::Configuration::FolderChooser do
     end
 
     context "when folders are not available" do
-      let(:remote_folders) { nil }
+      let(:connection_folders) { nil }
 
       before do
         allow(Imap::Backup::Configuration::Setup.highline).

data/spec/unit/imap/backup/configuration/gmail_oauth2_spec.rb

@@ -1,6 +1,9 @@
 describe Imap::Backup::Configuration::GmailOauth2 do
   include HighLineTestHelpers
 
+  CLIENT_ID = "my_client_id".freeze
+  CLIENT_SECRET = "my_client_secret".freeze
+
   subject { described_class.new(account) }
 
   let(:authorization_url) { "some long authorization_url" }
@@ -11,6 +14,7 @@ describe Imap::Backup::Configuration::GmailOauth2 do
   let(:input) { highline_streams[0] }
   let(:output) { highline_streams[1] }
   let(:account) { {} }
+  let(:user_input) { %W(my_client_id\n my_secret\n my_code\n) }
 
   let(:authorizer) do
     instance_double(
@@ -25,23 +29,31 @@ describe Imap::Backup::Configuration::GmailOauth2 do
       load: json_token
     )
   end
+  let(:token) do
+    instance_double(
+      Gmail::Authenticator::ImapBackupToken,
+      valid?: valid,
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET
+    )
+  end
+  let(:valid) { false }
 
   before do
     allow(Google::Auth::UserAuthorizer).
       to receive(:new) { authorizer }
     allow(Google::Auth::Stores::InMemoryTokenStore).
       to receive(:new) { token_store }
+    allow(Gmail::Authenticator::ImapBackupToken).
+      to receive(:new) { token }
 
     allow(highline).to receive(:ask).and_call_original
+    allow(highline).to receive(:agree).and_call_original
 
     allow(Kernel).to receive(:system)
     allow(Kernel).to receive(:puts)
 
-    allow(input).to receive(:gets).and_return(
-      "my_client_id\n",
-      "my_secret\n",
-      "my_code\n"
-    )
+    allow(input).to receive(:gets).and_return(*user_input)
   end
 
   describe "#run" do
@@ -80,5 +92,30 @@ describe Imap::Backup::Configuration::GmailOauth2 do
     it "includes the client_secret in the credentials" do
       expect(result).to match('"client_secret":"my_secret"')
     end
+
+    context "when the account already has client info" do
+      let(:valid) { true }
+      let(:user_input) { %W(yes\n) }
+
+      it "requests confirmation of client info" do
+        expect(highline).to have_received(:agree).with("Use existing client info?")
+      end
+
+      context "when yhe user says 'no'" do
+        let(:user_input) { %W(no\n) }
+
+        it "requests client_id" do
+          expect(highline).to have_received(:ask).with("client_id: ")
+        end
+
+        it "requests client_secret" do
+          expect(highline).to have_received(:ask).with("client_secret: ")
+        end
+
+        it "requests the success code" do
+          expect(highline).to have_received(:ask).with("success code: ")
+        end
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imap-backup
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.3.1
 platform: ruby
 authors:
 - Joe Yates
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-07 00:00:00.000000000 Z
+date: 2021-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gmail_xoauth
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -158,12 +172,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
 - ".gitignore"
 - ".rspec"
 - ".rspec-all"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -221,6 +235,7 @@ files:
 - lib/imap/backup/uploader.rb
 - lib/imap/backup/utils.rb
 - lib/imap/backup/version.rb
+- lib/retry_on_error.rb
 - spec/features/backup_spec.rb
 - spec/features/helper.rb
 - spec/features/restore_spec.rb
@@ -275,7 +290,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Backup GMail (or other IMAP) accounts to disk

data/.travis.yml

@@ -1,25 +0,0 @@
-language: ruby
-
-services:
-  - docker
-
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - 2.7
-  - jruby-19mode
-
-branches:
-  only:
-    - master
-
-before_install:
-  - gem update --system
-  - gem update bundler
-
-script:
-  - docker pull antespi/docker-imap-devel:latest
-  - docker run -d --env MAIL_ADDRESS=address@example.org --env MAIL_PASS=pass --env MAILNAME=example.org --publish 8993:993 antespi/docker-imap-devel:latest
-  - sleep 10
-  - bundle exec rake