imap-backup 2.1.1 → 3.0.0

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

@@ -0,0 +1,84 @@
+describe Imap::Backup::Configuration::GmailOauth2 do
+  include HighLineTestHelpers
+
+  subject { described_class.new(account) }
+
+  let(:authorization_url) { "some long authorization_url" }
+  let(:credentials) { "credentials" }
+  let(:json_token) { '{"sentinel":"foo"}' }
+  let!(:highline_streams) { prepare_highline }
+  let(:highline) { Imap::Backup::Configuration::Setup.highline }
+  let(:input) { highline_streams[0] }
+  let(:output) { highline_streams[1] }
+  let(:account) { {} }
+
+  let(:authorizer) do
+    instance_double(
+      Google::Auth::UserAuthorizer,
+      get_authorization_url: authorization_url,
+      get_and_store_credentials_from_code: credentials
+    )
+  end
+  let(:token_store) do
+    instance_double(
+      Google::Auth::Stores::InMemoryTokenStore,
+      load: json_token
+    )
+  end
+
+  before do
+    allow(Google::Auth::UserAuthorizer).
+      to receive(:new) { authorizer }
+    allow(Google::Auth::Stores::InMemoryTokenStore).
+      to receive(:new) { token_store }
+
+    allow(highline).to receive(:ask).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"
+    )
+  end
+
+  describe "#run" do
+    let!(:result) { subject.run }
+
+    it "clears the screen" do
+      expect(Kernel).to have_received(:system).with("clear")
+    end
+
+    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 "displays the authorization URL" do
+      expect(Kernel).
+        to have_received(:puts).
+        with(/#{authorization_url}/)
+    end
+
+    it "requests the success code" do
+      expect(highline).to have_received(:ask).with("success code: ")
+    end
+
+    it "requests an access_token via the code" do
+      expect(authorizer).to have_received(:get_and_store_credentials_from_code)
+    end
+
+    it "returns the credentials" do
+      expect(result).to match('"sentinel":"foo"')
+    end
+
+    it "includes the client_secret in the credentials" do
+      expect(result).to match('"client_secret":"my_secret"')
+    end
+  end
+end

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

@@ -35,18 +35,21 @@ describe Imap::Backup::Configuration::List do
       allow(Imap::Backup::Configuration::Store).
         to receive(:exist?) { config_exists }
       allow(Imap::Backup).to receive(:setup_logging)
-      subject.setup_logging
     end
 
     it "sets global logging level" do
-      expect(Imap::Backup).to have_received(:setup_logging).with(store)
+      expect(Imap::Backup).to receive(:setup_logging).with(store)
+
+      subject.setup_logging
     end
 
     context "without a config" do
       let(:config_exists) { false }
 
       it "does nothing" do
-        expect(Imap::Backup).to_not have_received(:setup_logging).with(store)
+        expect(Imap::Backup).to_not receive(:setup_logging).with(store)
+
+        subject.setup_logging
       end
     end
   end

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

@@ -1,8 +1,28 @@
-# rubocop:disable RSpec/NestedGroups
-
 describe Imap::Backup::Configuration::Setup do
   include HighLineTestHelpers
 
+  subject { described_class.new }
+
+  let(:normal) { {username: "account@example.com"} }
+  let(:accounts) { [normal] }
+  let(:store) do
+    instance_double(
+      Imap::Backup::Configuration::Store,
+      "accounts": accounts,
+      "path": "/base/path",
+      "save": nil,
+      "debug?": debug,
+      "debug=": nil,
+      "modified?": modified
+    )
+  end
+  let(:debug) { false }
+  let(:modified) { false }
+  let!(:highline_streams) { prepare_highline }
+  let(:input) { highline_streams[0] }
+  let(:output) { highline_streams[1] }
+  let(:gmail_imap_server) { "imap.gmail.com" }
+
   describe "#initialize" do
     context "without a config file" do
       it "works" do
@@ -12,27 +32,6 @@ describe Imap::Backup::Configuration::Setup do
   end
 
   describe "#run" do
-    subject { described_class.new }
-
-    let(:normal) { {username: "account@example.com"} }
-    let(:accounts) { [normal] }
-    let(:store) do
-      instance_double(
-        Imap::Backup::Configuration::Store,
-        "accounts": accounts,
-        "path": "/base/path",
-        "save": nil,
-        "debug?": debug,
-        "debug=": nil,
-        "modified?": modified
-      )
-    end
-    let(:debug) { false }
-    let(:modified) { false }
-    let!(:highline_streams) { prepare_highline }
-    let(:input) { highline_streams[0] }
-    let(:output) { highline_streams[1] }
-
     before do
       allow(Imap::Backup::Configuration::Store).to receive(:new) { store }
       allow(Imap::Backup).to receive(:setup_logging)
@@ -52,15 +51,15 @@ describe Imap::Backup::Configuration::Setup do
     end
 
     it "clears the screen" do
-      subject.run
+      expect(Kernel).to receive(:system).with("clear")
 
-      expect(Kernel).to have_received(:system).with("clear")
+      subject.run
     end
 
     it "updates logging status" do
-      subject.run
+      expect(Imap::Backup).to receive(:setup_logging)
 
-      expect(Imap::Backup).to have_received(:setup_logging)
+      subject.run
     end
 
     describe "listing" do
@@ -97,43 +96,66 @@ describe Imap::Backup::Configuration::Setup do
       before do
         allow(input).to receive(:gets).and_return("1\n", "exit\n")
         allow(Imap::Backup::Configuration::Asker).to receive(:email).
-          with(no_args).and_return("new@example.com")
+          with(no_args) { "new@example.com" }
         allow(Imap::Backup::Configuration::Account).to receive(:new).
-          with(store, normal, anything).and_return(account)
-
-        subject.run
+          with(store, normal, anything) { account }
       end
 
       it "edits the account" do
-        expect(account).to have_received(:run)
+        expect(account).to receive(:run)
+
+        subject.run
       end
     end
 
     context "when adding accounts" do
       let(:blank_account) do
         {
-          username: "new@example.com",
+          username: added_email,
           password: "",
-          local_path: "/base/path/new_example.com",
+          local_path: local_path,
           folders: []
         }
       end
       let(:account) do
         instance_double(Imap::Backup::Configuration::Account, run: nil)
       end
+      let(:added_email) { "new@example.com" }
+      let(:local_path) { "/base/path/new_example.com" }
 
       before do
         allow(input).to receive(:gets).and_return("add\n", "exit\n")
         allow(Imap::Backup::Configuration::Asker).to receive(:email).
-          with(no_args).and_return("new@example.com")
+          with(no_args) { added_email }
         allow(Imap::Backup::Configuration::Account).to receive(:new).
-          with(store, blank_account, anything).and_return(account)
+          with(store, anything, anything) { account }
 
         subject.run
       end
 
-      it "adds account data" do
-        expect(accounts[1]).to eq(blank_account)
+      it "sets username" do
+        expect(accounts[1][:username]).to eq(added_email)
+      end
+
+      it "sets blank password" do
+        expect(accounts[1][:password]).to eq("")
+      end
+
+      it "sets local_path" do
+        expect(accounts[1][:local_path]).to eq(local_path)
+      end
+
+      it "sets folders" do
+        expect(accounts[1][:folders]).to eq([])
+      end
+
+      context "when the account is a GMail account" do
+        let(:added_email) { "new@gmail.com" }
+        let(:local_path) { "/base/path/new_gmail.com" }
+
+        it "sets the server" do
+          expect(accounts[1][:server]).to eq(gmail_imap_server)
+        end
       end
 
       it "doesn't flag the unedited account as modified" do
@@ -145,20 +167,25 @@ describe Imap::Backup::Configuration::Setup do
       context "when debug logging is disabled" do
         before do
           allow(input).to receive(:gets).and_return("start\n", "exit\n")
-          subject.run
         end
 
         it "shows a menu item" do
+          subject.run
+
           expect(output.string).to include("start logging")
         end
 
         context "when selected" do
           it "sets the debug flag" do
-            expect(store).to have_received(:debug=).with(true)
+            expect(store).to receive(:debug=).with(true)
+
+            subject.run
           end
 
           it "updates logging status" do
-            expect(Imap::Backup).to have_received(:setup_logging).twice
+            expect(Imap::Backup).to receive(:setup_logging).twice
+
+            subject.run
           end
         end
       end
@@ -168,10 +195,11 @@ describe Imap::Backup::Configuration::Setup do
 
         before do
           allow(input).to receive(:gets).and_return("stop\n", "exit\n")
-          subject.run
         end
 
         it "shows a menu item" do
+          subject.run
+
           expect(output.string).to include("stop logging")
         end
 
@@ -181,11 +209,15 @@ describe Imap::Backup::Configuration::Setup do
           end
 
           it "unsets the debug flag" do
-            expect(store).to have_received(:debug=).with(false)
+            expect(store).to receive(:debug=).with(false)
+
+            subject.run
           end
 
           it "updates logging status" do
-            expect(Imap::Backup).to have_received(:setup_logging).twice
+            expect(Imap::Backup).to receive(:setup_logging).twice
+
+            subject.run
           end
         end
       end
@@ -193,45 +225,48 @@ describe Imap::Backup::Configuration::Setup do
 
     context "when 'save' is selected" do
       before do
-        allow(input).to receive(:gets).and_return("save\n")
-        subject.run
+        allow(input).to receive(:gets) { "save\n" }
       end
 
       it "exits" do
         # N.B. this will hang forever if save does not cause an exit
+        subject.run
       end
 
       it "saves the configuration" do
-        expect(store).to have_received(:save)
+        expect(store).to receive(:save)
+
+        subject.run
       end
     end
 
     context "when 'exit without saving' is selected" do
       before do
-        allow(input).to receive(:gets).and_return("exit\n")
-
-        subject.run
+        allow(input).to receive(:gets) { "exit\n" }
       end
 
       it "exits" do
         # N.B. this will hang forever if quit does not cause an exit
+        subject.run
       end
 
       context "when the configuration is modified" do
         let(:modified) { true }
 
         it "doesn't save the configuration" do
-          expect(store).to_not have_received(:save)
+          expect(store).to_not receive(:save)
+
+          subject.run
         end
       end
 
       context "when the configuration isn't modified" do
         it "doesn't save the configuration" do
-          expect(store).to_not have_received(:save)
+          expect(store).to_not receive(:save)
+
+          subject.run
         end
       end
     end
   end
 end
-
-# rubocop:enable RSpec/NestedGroups

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

@@ -20,11 +20,11 @@ describe Imap::Backup::Configuration::Store do
     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)
+      to receive(:stat).with(directory) { 0o700 }
     allow(Imap::Backup::Utils).
-      to receive(:stat).with(file_path).and_return(0o600)
-    allow(Imap::Backup::Utils).to receive(:check_permissions).and_return(nil)
-    allow(File).to receive(:read).with(file_path).and_return(configuration)
+      to receive(:stat).with(file_path) { 0o600 }
+    allow(Imap::Backup::Utils).to receive(:check_permissions) { nil }
+    allow(File).to receive(:read).with(file_path) { configuration }
   end
 
   describe ".exist?" do
@@ -140,19 +140,19 @@ describe Imap::Backup::Configuration::Store do
       allow(FileUtils).to receive(:mkdir)
       allow(FileUtils).to receive(:chmod)
       allow(File).to receive(:open).with(file_path, "w").and_yield(file)
-      allow(JSON).to receive(:pretty_generate).and_return("JSON output")
+      allow(JSON).to receive(:pretty_generate) { "JSON output" }
     end
 
     it "creates the config directory" do
-      subject.save
+      expect(FileUtils).to receive(:mkdir).with(directory)
 
-      expect(FileUtils).to have_received(:mkdir).with(directory)
+      subject.save
     end
 
     it "saves the configuration" do
-      subject.save
+      expect(file).to receive(:write).with("JSON output")
 
-      expect(file).to have_received(:write).with("JSON output")
+      subject.save
     end
 
     context "when accounts are modified" do
@@ -164,7 +164,9 @@ describe Imap::Backup::Configuration::Store do
         expected = Marshal.load(Marshal.dump(data))
         expected[:accounts][0].delete(:modified)
 
-        expect(JSON).to have_received(:pretty_generate).with(expected)
+        expect(JSON).to receive(:pretty_generate).with(expected)
+
+        subject.save
       end
     end
 
@@ -176,21 +178,21 @@ describe Imap::Backup::Configuration::Store do
         ]
       end
 
-      before { subject.save }
-
       it "does not save them" do
         expected = Marshal.load(Marshal.dump(data))
         expected[:accounts].pop
 
-        expect(JSON).to have_received(:pretty_generate).with(expected)
+        expect(JSON).to receive(:pretty_generate).with(expected)
+
+        subject.save
       end
     end
 
     context "when file permissions are too open" do
-      before { subject.save }
-
       it "sets them to 0600" do
-        expect(FileUtils).to have_received(:chmod).with(0o600, file_path)
+        expect(FileUtils).to receive(:chmod).with(0o600, file_path)
+
+        subject.save
       end
     end