imap-backup 3.4.0 → 4.0.0.rc3

data/lib/gmail/authenticator.rb

@@ -1,160 +0,0 @@
-require "googleauth"
-require "google/auth/stores/in_memory_token_store"
-
-module Gmail; end
-
-class Gmail::Authenticator
-  class MalformedImapBackupToken < StandardError; end
-
-  class ImapBackupToken
-    attr_reader :token
-
-    def self.from(
-      access_token:,
-      client_id:,
-      client_secret:,
-      expiration_time_millis:,
-      refresh_token:
-    )
-      {
-        access_token: access_token,
-        client_id: client_id,
-        client_secret: client_secret,
-        expiration_time_millis: expiration_time_millis,
-        refresh_token: refresh_token
-      }.to_json
-    end
-
-    def initialize(token)
-      @token = token
-    end
-
-    def valid?
-      return false if !body
-      return false if !access_token
-      return false if !client_id
-      return false if !client_secret
-      return false if !expiration_time_millis
-      return false if !refresh_token
-
-      true
-    end
-
-    def access_token
-      body["access_token"]
-    end
-
-    def client_id
-      body["client_id"]
-    end
-
-    def client_secret
-      body["client_secret"]
-    end
-
-    def expiration_time_millis
-      body["expiration_time_millis"]
-    end
-
-    def refresh_token
-      body["refresh_token"]
-    end
-
-    private
-
-    def body
-      @body ||= JSON.parse(token)
-    rescue JSON::ParserError
-      nil
-    end
-  end
-
-  GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
-  OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
-
-  attr_reader :email
-  attr_reader :token
-
-  def self.refresh_token?(text)
-    ImapBackupToken.new(text).valid?
-  end
-
-  def initialize(email:, token:)
-    @email = email
-    @token = token
-  end
-
-  def authorization_url
-    authorizer.get_authorization_url(base_url: OOB_URI)
-  end
-
-  def credentials
-    authorizer.get_credentials(email).tap do |c|
-      c.refresh! if c.expired?
-    end
-  end
-
-  def credentials_from_code(code)
-    authorizer.get_credentials_from_code(
-      user_id: email,
-      code: code,
-      base_url: OOB_URI
-    )
-  end
-
-  private
-
-  def auth_client_id
-    @auth_client_id = Google::Auth::ClientId.new(client_id, client_secret)
-  end
-
-  def authorizer
-    @authorizer ||= Google::Auth::UserAuthorizer.new(
-      auth_client_id, GMAIL_READ_SCOPE, token_store
-    )
-  end
-
-  def access_token
-    imap_backup_token.access_token
-  end
-
-  def client_id
-    imap_backup_token.client_id
-  end
-
-  def client_secret
-    imap_backup_token.client_secret
-  end
-
-  def expiration_time_millis
-    imap_backup_token.expiration_time_millis
-  end
-
-  def refresh_token
-    imap_backup_token.refresh_token
-  end
-
-  def imap_backup_token
-    @imap_backup_token ||=
-      ImapBackupToken.new(token).tap do |t|
-        raise MalformedImapBackupToken if !t.valid?
-      end
-  end
-
-  def store_token
-    {
-      "client_id" => client_id,
-      "access_token" => access_token,
-      "refresh_token" => refresh_token,
-      "scope": [GMAIL_READ_SCOPE],
-      "expiration_time_millis": expiration_time_millis
-    }.to_json
-  end
-
-  def token_store
-    @token_store ||=
-      Google::Auth::Stores::InMemoryTokenStore.new.tap do |t|
-        t.store(email, store_token)
-      end
-  end
-end

data/lib/google/auth/stores/in_memory_token_store.rb

@@ -1,9 +0,0 @@
-module Google; end
-module Google::Auth; end
-module Google::Auth::Stores; end
-
-class Google::Auth::Stores::InMemoryTokenStore < Hash
-  def load(id)
-    self[id]
-  end
-end

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

@@ -1,102 +0,0 @@
-module Imap::Backup
-  module Configuration; end
-
-  class Configuration::GmailOauth2
-    BANNER = <<~BANNER.freeze
-      GMail OAuth2 Setup
-
-      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/blob/main/docs/setting-up-gmail-with-oauth2.md
-
-    BANNER
-
-    GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
-    OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
-
-    attr_reader :account
-    attr_reader :client_id
-    attr_reader :client_secret
-
-    def initialize(account)
-      @account = account
-    end
-
-    def run
-      Kernel.system("clear")
-      Kernel.puts BANNER
-
-      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
-
-        Open the following URL in your browser
-
-        #{authorization_url}
-
-        Then copy the success code
-
-      MESSAGE
-
-      @code = highline.ask("success code: ")
-      @credentials = authorizer.get_and_store_credentials_from_code(
-        user_id: email, code: @code, base_url: OOB_URI
-      )
-
-      raise "Failed" if !@credentials
-
-      new_token = JSON.parse(token_store.load(email))
-      new_token["client_secret"] = client_secret
-      new_token.to_json
-    end
-
-    private
-
-    def email
-      account[:username]
-    end
-
-    def password
-      account[:password]
-    end
-
-    def token
-      @token ||= Gmail::Authenticator::ImapBackupToken.new(password)
-    end
-
-    def highline
-      Configuration::Setup.highline
-    end
-
-    def auth_client_id
-      @auth_client_id = Google::Auth::ClientId.new(client_id, client_secret)
-    end
-
-    def authorizer
-      @authorizer ||= Google::Auth::UserAuthorizer.new(
-        auth_client_id, GMAIL_READ_SCOPE, token_store
-      )
-    end
-
-    def token_store
-      @token_store ||= Google::Auth::Stores::InMemoryTokenStore.new
-    end
-
-    def authorization_url
-      authorizer.get_authorization_url(base_url: OOB_URI)
-    end
-  end
-end

data/spec/unit/gmail/authenticator_spec.rb

@@ -1,138 +0,0 @@
-require "gmail/authenticator"
-require "googleauth"
-
-describe Gmail::Authenticator do
-  ACCESS_TOKEN = "access_token".freeze
-  AUTHORIZATION_URL = "authorization_url".freeze
-  CLIENT_ID = "client_id".freeze
-  CLIENT_SECRET = "client_secret".freeze
-  CODE = "code".freeze
-  CREDENTIALS = "credentials".freeze
-  EMAIL = "email".freeze
-  EXPIRATION_TIME_MILLIS = "expiration_time_millis".freeze
-  GMAIL_READ_SCOPE = "https://mail.google.com/".freeze
-  IMAP_BACKUP_TOKEN = "imap_backup_token".freeze
-  OOB_URI = "urn:ietf:wg:oauth:2.0:oob".freeze
-  REFRESH_TOKEN = "refresh_token".freeze
-
-  subject { described_class.new(**params) }
-
-  let(:params) do
-    {
-      email: EMAIL,
-      token: IMAP_BACKUP_TOKEN
-    }
-  end
-
-  let(:authorizer) do
-    instance_double(Google::Auth::UserAuthorizer)
-  end
-
-  let(:imap_backup_token) do
-    instance_double(
-      Gmail::Authenticator::ImapBackupToken,
-      access_token: ACCESS_TOKEN,
-      client_id: CLIENT_ID,
-      client_secret: CLIENT_SECRET,
-      expiration_time_millis: EXPIRATION_TIME_MILLIS,
-      refresh_token: REFRESH_TOKEN,
-      valid?: true
-    )
-  end
-
-  let(:token_store) do
-    instance_double(Google::Auth::Stores::InMemoryTokenStore)
-  end
-
-  let(:credentials) do
-    instance_double(Google::Auth::UserRefreshCredentials, refresh!: true)
-  end
-
-  let(:expired) { false }
-
-  before do
-    allow(Google::Auth::UserAuthorizer).
-      to receive(:new).
-        with(
-          instance_of(Google::Auth::ClientId),
-          GMAIL_READ_SCOPE,
-          token_store
-        ) { authorizer }
-    allow(authorizer).to receive(:get_authorization_url).
-      with(base_url: OOB_URI) { AUTHORIZATION_URL }
-    allow(authorizer).to receive(:get_credentials).
-      with(EMAIL) { credentials }
-    allow(authorizer).to receive(:get_credentials_from_code).
-      with(user_id: EMAIL, code: CODE, base_url: OOB_URI) { CREDENTIALS }
-
-    allow(Google::Auth::UserRefreshCredentials).
-      to receive(:new) { credentials }
-    allow(credentials).to receive(:expired?) { expired }
-
-    allow(Google::Auth::Stores::InMemoryTokenStore).
-      to receive(:new) { token_store }
-    allow(token_store).to receive(:store).
-      with(EMAIL, anything) # TODO: use a JSON matcher
-    allow(Gmail::Authenticator::ImapBackupToken).
-      to receive(:new).
-        with(IMAP_BACKUP_TOKEN) { imap_backup_token }
-  end
-
-  describe "#initialize" do
-    [:email, :token].each do |param|
-      context "parameter #{param}" do
-        let(:params) { super().dup.reject { |k| k == param } }
-
-        it "is expected" do
-          expect { subject }.to raise_error(
-            ArgumentError, /missing keyword: :?#{param}/
-          )
-        end
-      end
-    end
-  end
-
-  describe "#credentials" do
-    let!(:result) { subject.credentials }
-
-    it "attempts to get credentials" do
-      expect(authorizer).to have_received(:get_credentials)
-    end
-
-    it "returns the result" do
-      expect(result).to eq(credentials)
-    end
-
-    context "when the access_token has expired" do
-      let(:expired) { true }
-
-      it "refreshes it" do
-        expect(credentials).to have_received(:refresh!)
-      end
-    end
-  end
-
-  describe "#authorization_url" do
-    let!(:result) { subject.authorization_url }
-
-    it "requests an authorization URL" do
-      expect(authorizer).to have_received(:get_authorization_url)
-    end
-
-    it "returns the result" do
-      expect(result).to eq(AUTHORIZATION_URL)
-    end
-  end
-
-  describe "#credentials_from_code" do
-    let!(:result) { subject.credentials_from_code(CODE) }
-
-    it "requests credentials" do
-      expect(authorizer).to have_received(:get_credentials_from_code)
-    end
-
-    it "returns credentials" do
-      expect(result).to eq(CREDENTIALS)
-    end
-  end
-end

data/spec/unit/google/auth/stores/in_memory_token_store_spec.rb

@@ -1,15 +0,0 @@
-require "google/auth/stores/in_memory_token_store"
-
-describe Google::Auth::Stores::InMemoryTokenStore do
-  KEY = "key".freeze
-  VALUE = "value".freeze
-
-  subject { described_class.new }
-
-  describe "#load" do
-    it "returns an item's value" do
-      subject[KEY] = VALUE
-      expect(subject.load(KEY)).to eq(VALUE)
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-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" }
-  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(:user_input) { %W(my_client_id\n my_secret\n my_code\n) }
-
-  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
-  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(*user_input)
-  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
-
-    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