doorkeeper-mongodb 5.3.0 → 5.4.0

data/spec/lib/oauth/token_response_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Doorkeeper::OAuth::TokenResponse do
-  subject { described_class.new(double.as_null_object) }
-
-  it "includes access token response headers" do
-    headers = subject.headers
-    expect(headers.fetch("Cache-Control")).to eq("no-store")
-    expect(headers.fetch("Pragma")).to eq("no-cache")
-  end
-
-  it "status is ok" do
-    expect(subject.status).to eq(:ok)
-  end
-
-  describe ".body" do
-    subject { described_class.new(access_token).body }
-
-    let(:access_token) do
-      double :access_token,
-             plaintext_token: "some-token",
-             expires_in: "3600",
-             expires_in_seconds: "300",
-             scopes_string: "two scopes",
-             plaintext_refresh_token: "some-refresh-token",
-             token_type: "bearer",
-             created_at: 0
-    end
-
-    it "includes :access_token" do
-      expect(subject["access_token"]).to eq("some-token")
-    end
-
-    it "includes :token_type" do
-      expect(subject["token_type"]).to eq("bearer")
-    end
-
-    # expires_in_seconds is returned as `expires_in` in order to match
-    # the OAuth spec (section 4.2.2)
-    it "includes :expires_in" do
-      expect(subject["expires_in"]).to eq("300")
-    end
-
-    it "includes :scope" do
-      expect(subject["scope"]).to eq("two scopes")
-    end
-
-    it "includes :refresh_token" do
-      expect(subject["refresh_token"]).to eq("some-refresh-token")
-    end
-
-    it "includes :created_at" do
-      expect(subject["created_at"]).to eq(0)
-    end
-  end
-
-  describe ".body filters out empty values" do
-    subject { described_class.new(access_token).body }
-
-    let(:access_token) do
-      double :access_token,
-             plaintext_token: "some-token",
-             expires_in_seconds: "",
-             scopes_string: "",
-             plaintext_refresh_token: "",
-             token_type: "bearer",
-             created_at: 0
-    end
-
-    it "includes :expires_in" do
-      expect(subject["expires_in"]).to be_nil
-    end
-
-    it "includes :scope" do
-      expect(subject["scope"]).to be_nil
-    end
-
-    it "includes :refresh_token" do
-      expect(subject["refresh_token"]).to be_nil
-    end
-  end
-end

data/spec/lib/oauth/token_spec.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Doorkeeper
-  unless defined?(AccessToken)
-    class AccessToken
-    end
-  end
-end
-
-RSpec.describe Doorkeeper::OAuth::Token do
-  describe ".from_request" do
-    let(:request) { double.as_null_object }
-
-    let(:method) do
-      ->(*) { "token-value" }
-    end
-
-    it "accepts anything that responds to #call" do
-      expect(method).to receive(:call).with(request)
-      described_class.from_request request, method
-    end
-
-    it "delegates methods received as symbols to described_class class" do
-      expect(described_class).to receive(:from_params).with(request)
-      described_class.from_request request, :from_params
-    end
-
-    it "stops at the first credentials found" do
-      not_called_method = double
-      expect(not_called_method).not_to receive(:call)
-      described_class.from_request request, ->(_r) {}, method, not_called_method
-    end
-
-    it "returns the credential from extractor method" do
-      credentials = described_class.from_request request, method
-      expect(credentials).to eq("token-value")
-    end
-  end
-
-  describe ".from_access_token_param" do
-    it "returns token from access_token parameter" do
-      request = double parameters: { access_token: "some-token" }
-      token   = described_class.from_access_token_param(request)
-      expect(token).to eq("some-token")
-    end
-  end
-
-  describe ".from_bearer_param" do
-    it "returns token from bearer_token parameter" do
-      request = double parameters: { bearer_token: "some-token" }
-      token   = described_class.from_bearer_param(request)
-      expect(token).to eq("some-token")
-    end
-  end
-
-  describe ".from_bearer_authorization" do
-    it "returns token from capitalized authorization bearer" do
-      request = double authorization: "Bearer SomeToken"
-      token   = described_class.from_bearer_authorization(request)
-      expect(token).to eq("SomeToken")
-    end
-
-    it "returns token from lowercased authorization bearer" do
-      request = double authorization: "bearer SomeToken"
-      token   = described_class.from_bearer_authorization(request)
-      expect(token).to eq("SomeToken")
-    end
-
-    it "does not return token if authorization is not bearer" do
-      request = double authorization: "MAC SomeToken"
-      token   = described_class.from_bearer_authorization(request)
-      expect(token).to be_blank
-    end
-  end
-
-  describe ".from_basic_authorization" do
-    it "returns token from capitalized authorization basic" do
-      request = double authorization: "Basic #{Base64.encode64 "SomeToken:"}"
-      token   = described_class.from_basic_authorization(request)
-      expect(token).to eq("SomeToken")
-    end
-
-    it "returns token from lowercased authorization basic" do
-      request = double authorization: "basic #{Base64.encode64 "SomeToken:"}"
-      token   = described_class.from_basic_authorization(request)
-      expect(token).to eq("SomeToken")
-    end
-
-    it "does not return token if authorization is not basic" do
-      request = double authorization: "MAC #{Base64.encode64 "SomeToken:"}"
-      token   = described_class.from_basic_authorization(request)
-      expect(token).to be_blank
-    end
-  end
-
-  describe ".authenticate" do
-    context "when refresh tokens are disabled (default)" do
-      context "when refresh tokens are enabled" do
-        it "does not revoke previous refresh_token if token was found" do
-          token = ->(_r) { "token" }
-          expect(
-            Doorkeeper::AccessToken,
-          ).to receive(:by_token).with("token").and_return(token)
-          expect(token).not_to receive(:revoke_previous_refresh_token!)
-          described_class.authenticate double, token
-        end
-      end
-
-      it "calls the finder if token was returned" do
-        token = ->(_r) { "token" }
-        expect(Doorkeeper::AccessToken).to receive(:by_token).with("token")
-        described_class.authenticate double, token
-      end
-    end
-
-    context "when token hashing is enabled" do
-      include_context "with token hashing enabled"
-
-      let(:hashed_token) { hashed_or_plain_token_func.call("token") }
-      let(:token) { ->(_r) { "token" } }
-
-      it "searches with the hashed token" do
-        expect(
-          Doorkeeper::AccessToken,
-        ).to receive(:find_by).with(token: hashed_token).and_return(token)
-        described_class.authenticate double, token
-      end
-    end
-
-    context "when refresh tokens are enabled" do
-      before do
-        Doorkeeper.configure do
-          orm DOORKEEPER_ORM
-          use_refresh_token
-        end
-      end
-
-      it "revokes previous refresh_token if token was found" do
-        token = ->(_r) { "token" }
-        expect(
-          Doorkeeper::AccessToken,
-        ).to receive(:by_token).with("token").and_return(token)
-        expect(token).to receive(:revoke_previous_refresh_token!)
-        described_class.authenticate double, token
-      end
-
-      it "calls the finder if token was returned" do
-        token = ->(_r) { "token" }
-        expect(Doorkeeper::AccessToken).to receive(:by_token).with("token")
-        described_class.authenticate double, token
-      end
-    end
-  end
-end

data/spec/lib/option_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Doorkeeper::Config::Option do
-  class Extension
-    def self.configure(&block)
-      @config = Config::Builder.new(Config.new, &block).build
-    end
-
-    def self.configuration
-      @config || (raise Errors::MissingConfiguration)
-    end
-
-    class Config
-      class Builder < Doorkeeper::Config::AbstractBuilder
-        def enforce_something
-          @config.instance_variable_set(:@enforce_something, true)
-        end
-      end
-
-      def enforce_something?
-        if defined?(@enforce_something)
-          @enforce_something
-        else
-          false
-        end
-      end
-
-      def self.builder_class
-        Config::Builder
-      end
-
-      extend Doorkeeper::Config::Option
-    end
-  end
-
-  it "allows to define custom options in extensions" do
-    expect do
-      Extension::Config.option(:some_option, default: 1)
-    end.not_to raise_error
-
-    Extension.configure do
-      some_option 20
-      enforce_something
-    end
-
-    expect(Extension.configuration.some_option).to eq(20)
-    expect(Extension.configuration.enforce_something?).to be(true)
-  end
-end

data/spec/lib/request/strategy_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Doorkeeper::Request::Strategy do
-  subject(:strategy) { described_class.new(server) }
-
-  let(:server) { double }
-
-  describe "#initialize" do
-    it "sets the server attribute" do
-      expect(strategy.server).to eq server
-    end
-  end
-
-  describe "#request" do
-    it "requires an implementation" do
-      expect { strategy.request }.to raise_exception NotImplementedError
-    end
-  end
-
-  describe "a sample Strategy subclass" do
-    subject(:strategy) { strategy_class.new(server) }
-
-    let(:fake_request) { double }
-
-    let(:strategy_class) do
-      subclass = Class.new(described_class) do
-        class << self
-          attr_accessor :fake_request
-        end
-
-        def request
-          self.class.fake_request
-        end
-      end
-
-      subclass.fake_request = fake_request
-      subclass
-    end
-
-    it "provides a request implementation" do
-      expect(strategy.request).to eq fake_request
-    end
-
-    it "authorizes the request" do
-      expect(fake_request).to receive :authorize
-      strategy.authorize
-    end
-  end
-end

data/spec/lib/secret_storing/base_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe ::Doorkeeper::SecretStoring::Base do
-  subject { described_class }
-
-  let(:instance) { double("instance", token: "foo") }
-
-  describe "#transform_secret" do
-    it "raises" do
-      expect { subject.transform_secret("foo") }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe "#store_secret" do
-    it "sends to response of #transform_secret to the instance" do
-      expect(described_class)
-        .to receive(:transform_secret).with("bar")
-        .and_return "bar+transform"
-
-      expect(instance).to receive(:token=).with "bar+transform"
-      result = subject.store_secret instance, :token, "bar"
-      expect(result).to eq "bar+transform"
-    end
-  end
-
-  describe "#restore_secret" do
-    it "raises" do
-      expect { subject.restore_secret(subject, :token) }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe "#allows_restoring_secrets?" do
-    it "does not allow it" do
-      expect(subject.allows_restoring_secrets?).to eq false
-    end
-  end
-
-  describe "validate_for" do
-    it "allows for valid model" do
-      expect(subject.validate_for(:application)).to eq true
-      expect(subject.validate_for(:token)).to eq true
-    end
-
-    it "raises for invalid model" do
-      expect { subject.validate_for(:wat) }.to raise_error(ArgumentError, /can not be used for wat/)
-    end
-  end
-
-  describe "secret_matches?" do
-    before do
-      allow(subject).to receive(:transform_secret) { |input| "transformed: #{input}" }
-    end
-
-    it "compares input with #transform_secret" do
-      expect(subject.secret_matches?("input", "input")).to eq false
-      expect(subject.secret_matches?("a", "transformed: a")).to eq true
-    end
-  end
-end

data/spec/lib/secret_storing/bcrypt_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "bcrypt"
-
-RSpec.describe ::Doorkeeper::SecretStoring::BCrypt do
-  subject { described_class }
-
-  let(:instance) { double("instance", token: "foo") }
-
-  describe "#transform_secret" do
-    it "creates a bcrypt password" do
-      expect(subject.transform_secret("foo")).to be_a BCrypt::Password
-    end
-  end
-
-  describe "#restore_secret" do
-    it "raises" do
-      expect { subject.restore_secret(instance, :token) }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe "#allows_restoring_secrets?" do
-    it "does not allow it" do
-      expect(subject.allows_restoring_secrets?).to eq false
-    end
-  end
-
-  describe "validate_for" do
-    it "allows for valid model" do
-      expect(subject.validate_for(:application)).to eq true
-    end
-
-    it "raises for invalid model" do
-      expect { subject.validate_for(:wat) }
-        .to raise_error(ArgumentError, /can only be used for storing application secrets/)
-      expect { subject.validate_for(:token) }
-        .to raise_error(ArgumentError, /can only be used for storing application secrets/)
-    end
-  end
-
-  describe "secret_matches?" do
-    it "compares input with #transform_secret" do
-      expect(subject.secret_matches?("input", "input")).to eq false
-
-      password = BCrypt::Password.create "foobar"
-      expect(subject.secret_matches?("foobar", password.to_s)).to eq true
-    end
-  end
-end

data/spec/lib/secret_storing/plain_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe ::Doorkeeper::SecretStoring::Plain do
-  subject { described_class }
-
-  let(:instance) { double("instance", token: "foo") }
-
-  describe "#transform_secret" do
-    it "raises" do
-      expect(subject.transform_secret("foo")).to eq "foo"
-    end
-  end
-
-  describe "#restore_secret" do
-    it "raises" do
-      expect(subject.restore_secret(instance, :token)).to eq "foo"
-    end
-  end
-
-  describe "#allows_restoring_secrets?" do
-    it "does allow it" do
-      expect(subject.allows_restoring_secrets?).to eq true
-    end
-  end
-
-  describe "validate_for" do
-    it "allows for valid model" do
-      expect(subject.validate_for(:application)).to eq true
-      expect(subject.validate_for(:token)).to eq true
-    end
-
-    it "raises for invalid model" do
-      expect { subject.validate_for(:wat) }.to raise_error(ArgumentError, /can not be used for wat/)
-    end
-  end
-
-  describe "secret_matches?" do
-    it "compares input with #transform_secret" do
-      expect(subject.secret_matches?("input", "input")).to eq true
-      expect(subject.secret_matches?("a", "b")).to eq false
-    end
-  end
-end

data/spec/lib/secret_storing/sha256_hash_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe ::Doorkeeper::SecretStoring::Sha256Hash do
-  subject { described_class }
-
-  let(:instance) { double("instance") }
-
-  let(:hash_function) do
-    ->(input) { ::Digest::SHA256.hexdigest(input) }
-  end
-
-  describe "#transform_secret" do
-    it "raises" do
-      expect(subject.transform_secret("foo")).to eq hash_function.call("foo")
-    end
-  end
-
-  describe "#restore_secret" do
-    it "raises" do
-      expect { subject.restore_secret(instance, :token) }.to raise_error(NotImplementedError)
-    end
-  end
-
-  describe "#allows_restoring_secrets?" do
-    it "does not allow it" do
-      expect(subject.allows_restoring_secrets?).to eq false
-    end
-  end
-
-  describe "validate_for" do
-    it "allows for valid model" do
-      expect(subject.validate_for(:application)).to eq true
-      expect(subject.validate_for(:token)).to eq true
-    end
-
-    it "raises for invalid model" do
-      expect { subject.validate_for(:wat) }.to raise_error(ArgumentError, /can not be used for wat/)
-    end
-  end
-
-  describe "secret_matches?" do
-    it "compares input with #transform_secret" do
-      expect(subject.secret_matches?("input", "input")).to eq false
-      expect(subject.secret_matches?("a", hash_function.call("a"))).to eq true
-    end
-  end
-end