doorkeeper 5.4.0.rc1 → 5.5.0

data/spec/lib/oauth/error_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Doorkeeper::OAuth::Error do
-  subject(:error) { described_class.new(:some_error, :some_state) }
-
-  it { expect(subject).to respond_to(:name) }
-  it { expect(subject).to respond_to(:state) }
-
-  describe "#description" do
-    it "is translated from translation messages" do
-      expect(I18n).to receive(:translate).with(
-        :some_error,
-        scope: %i[doorkeeper errors messages],
-        default: :server_error,
-      )
-      error.description
-    end
-  end
-end

data/spec/lib/oauth/forbidden_token_response_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Doorkeeper::OAuth::ForbiddenTokenResponse do
-  describe "#name" do
-    it { expect(subject.name).to eq(:invalid_scope) }
-  end
-
-  describe "#status" do
-    it { expect(subject.status).to eq(:forbidden) }
-  end
-
-  describe ".from_scopes" do
-    it "should have a list of acceptable scopes" do
-      response = described_class.from_scopes(["public"])
-      expect(response.description).to include("public")
-    end
-  end
-end

data/spec/lib/oauth/helpers/scope_checker_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Doorkeeper::OAuth::Helpers
-  describe ScopeChecker, ".valid?" do
-    let(:server_scopes) { Doorkeeper::OAuth::Scopes.new }
-
-    it "is valid if scope is present" do
-      server_scopes.add :scope
-      expect(ScopeChecker.valid?(scope_str: "scope", server_scopes: server_scopes)).to be_truthy
-    end
-
-    it "is invalid if includes tabs space" do
-      expect(ScopeChecker.valid?(scope_str: "\tsomething", server_scopes: server_scopes)).to be_falsey
-    end
-
-    it "is invalid if scope is not present" do
-      expect(ScopeChecker.valid?(scope_str: nil, server_scopes: server_scopes)).to be_falsey
-    end
-
-    it "is invalid if scope is blank" do
-      expect(ScopeChecker.valid?(scope_str: " ", server_scopes: server_scopes)).to be_falsey
-    end
-
-    it "is invalid if includes return space" do
-      expect(ScopeChecker.valid?(scope_str: "scope\r", server_scopes: server_scopes)).to be_falsey
-    end
-
-    it "is invalid if includes new lines" do
-      expect(ScopeChecker.valid?(scope_str: "scope\nanother", server_scopes: server_scopes)).to be_falsey
-    end
-
-    it "is invalid if any scope is not included in server scopes" do
-      expect(ScopeChecker.valid?(scope_str: "scope another", server_scopes: server_scopes)).to be_falsey
-    end
-
-    context "with application_scopes" do
-      let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string "common svr"
-      end
-      let(:application_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string "app123"
-      end
-
-      it "is valid if scope is included in the application scope list" do
-        expect(ScopeChecker.valid?(
-                 scope_str: "app123",
-                 server_scopes: server_scopes,
-                 app_scopes: application_scopes,
-               )).to be_truthy
-      end
-
-      it "is invalid if any scope is not included in the application" do
-        expect(ScopeChecker.valid?(
-                 scope_str: "svr",
-                 server_scopes: server_scopes,
-                 app_scopes: application_scopes,
-               )).to be_falsey
-      end
-    end
-
-    context "with grant_type" do
-      let(:server_scopes) do
-        Doorkeeper::OAuth::Scopes.from_string "scope1 scope2"
-      end
-
-      context "with scopes_by_grant_type not configured for grant_type" do
-        it "is valid if the scope is in server scopes" do
-          expect(ScopeChecker.valid?(
-                   scope_str: "scope1",
-                   server_scopes: server_scopes,
-                   grant_type: Doorkeeper::OAuth::PASSWORD,
-                 )).to be_truthy
-        end
-
-        it "is invalid if the scope is not in server scopes" do
-          expect(ScopeChecker.valid?(
-                   scope_str: "unknown",
-                   server_scopes: server_scopes,
-                   grant_type: Doorkeeper::OAuth::PASSWORD,
-                 )).to be_falsey
-        end
-      end
-
-      context "when scopes_by_grant_type configured for grant_type" do
-        before do
-          allow(Doorkeeper.configuration).to receive(:scopes_by_grant_type)
-            .and_return(password: [:scope1])
-        end
-
-        it "is valid if the scope is permitted for grant_type" do
-          expect(ScopeChecker.valid?(
-                   scope_str: "scope1",
-                   server_scopes: server_scopes,
-                   grant_type: Doorkeeper::OAuth::PASSWORD,
-                 )).to be_truthy
-        end
-
-        it "is invalid if the scope is permitted for grant_type" do
-          expect(ScopeChecker.valid?(
-                   scope_str: "scope2",
-                   server_scopes: server_scopes,
-                   grant_type: Doorkeeper::OAuth::PASSWORD,
-                 )).to be_falsey
-        end
-      end
-    end
-  end
-end

data/spec/lib/oauth/helpers/unique_token_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Doorkeeper::OAuth::Helpers
-  describe UniqueToken do
-    let :generator do
-      ->(size) { "a" * size }
-    end
-
-    it "is able to customize the generator method" do
-      token = UniqueToken.generate(generator: generator)
-      expect(token).to eq("a" * 32)
-    end
-
-    it "is able to customize the size of the token" do
-      token = UniqueToken.generate(generator: generator, size: 2)
-      expect(token).to eq("aa")
-    end
-  end
-end

data/spec/lib/oauth/helpers/uri_checker_spec.rb

@@ -1,262 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Doorkeeper::OAuth::Helpers
-  describe URIChecker do
-    describe ".valid?" do
-      it "is valid for valid uris" do
-        uri = "http://app.co"
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it "is valid if include path param" do
-        uri = "http://app.co/path"
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it "is valid if include query param" do
-        uri = "http://app.co/?query=1"
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it "is invalid if uri includes fragment" do
-        uri = "http://app.co/test#fragment"
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is invalid if scheme is missing" do
-        uri = "app.co"
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is invalid if is a relative uri" do
-        uri = "/abc/123"
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is invalid if is not a url" do
-        uri = "http://"
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is invalid if localhost is resolved as as scheme (no scheme specified)" do
-        uri = "localhost:8080"
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is invalid if scheme is missing #2" do
-        uri = "app.co:80"
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is invalid if is not an uri" do
-        uri = "   "
-        expect(URIChecker.valid?(uri)).to be_falsey
-      end
-
-      it "is valid for custom schemes" do
-        uri = "com.example.app:/test"
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-
-      it "is valid for custom schemes with authority marker (common misconfiguration)" do
-        uri = "com.example.app://test"
-        expect(URIChecker.valid?(uri)).to be_truthy
-      end
-    end
-
-    describe ".matches?" do
-      it "is true if both url matches" do
-        uri = client_uri = "http://app.co/aaa"
-        expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-      end
-
-      it "ignores query parameter on comparsion" do
-        uri = "http://app.co/?query=hello"
-        client_uri = "http://app.co"
-        expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-      end
-
-      it "doesn't allow non-matching domains through" do
-        uri = "http://app.abc/?query=hello"
-        client_uri = "http://app.co"
-        expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-      end
-
-      it "doesn't allow non-matching domains that don't start at the beginning" do
-        uri = "http://app.co/?query=hello"
-        client_uri = "http://example.com?app.co=test"
-        expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-      end
-
-      context "loopback IP redirect URIs" do
-        it "ignores port for same URIs" do
-          uri = "http://127.0.0.1:5555/auth/callback"
-          client_uri = "http://127.0.0.1:48599/auth/callback"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-
-          uri = "http://[::1]:5555/auth/callback"
-          client_uri = "http://[::1]:5555/auth/callback"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-        end
-
-        it "doesn't ignore port for URIs with different queries" do
-          uri = "http://127.0.0.1:5555/auth/callback"
-          client_uri = "http://127.0.0.1:48599/auth/callback2"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-        end
-      end
-
-      context "client registered query params" do
-        it "doesn't allow query being absent" do
-          uri = "http://app.co"
-          client_uri = "http://app.co/?vendorId=AJ4L7XXW9"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-        end
-
-        it "is false if query values differ but key same" do
-          uri = "http://app.co/?vendorId=pancakes"
-          client_uri = "http://app.co/?vendorId=waffles"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-        end
-
-        it "is false if query values same but key differs" do
-          uri = "http://app.co/?foo=pancakes"
-          client_uri = "http://app.co/?bar=pancakes"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-        end
-
-        it "is false if query present and match, but unknown queries present" do
-          uri = "http://app.co/?vendorId=pancakes&unknown=query"
-          client_uri = "http://app.co/?vendorId=waffles"
-          expect(URIChecker.matches?(uri, client_uri)).to be_falsey
-        end
-
-        it "is true if queries are present and matche" do
-          uri = "http://app.co/?vendorId=AJ4L7XXW9&foo=bar"
-          client_uri = "http://app.co/?vendorId=AJ4L7XXW9&foo=bar"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-        end
-
-        it "is true if queries are present, match and in different order" do
-          uri = "http://app.co/?bing=bang&foo=bar"
-          client_uri = "http://app.co/?foo=bar&bing=bang"
-          expect(URIChecker.matches?(uri, client_uri)).to be_truthy
-        end
-      end
-    end
-
-    describe ".valid_for_authorization?" do
-      it "is true if valid and matches" do
-        uri = client_uri = "http://app.co/aaa"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-
-        uri = client_uri = "http://app.co/aaa?b=c"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-      end
-
-      it "is true if uri includes blank query" do
-        uri = client_uri = "http://app.co/aaa?"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-
-        uri = "http://app.co/aaa?"
-        client_uri = "http://app.co/aaa"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-
-        uri = "http://app.co/aaa"
-        client_uri = "http://app.co/aaa?"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-      end
-
-      it "is false if valid and mismatches" do
-        uri = "http://app.co/aaa"
-        client_uri = "http://app.co/bbb"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_falsey
-      end
-
-      it "is true if valid and included in array" do
-        uri = "http://app.co/aaa"
-        client_uri = "http://example.com/bbb\nhttp://app.co/aaa"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_truthy
-      end
-
-      it "is false if valid and not included in array" do
-        uri = "http://app.co/aaa"
-        client_uri = "http://example.com/bbb\nhttp://app.co/cc"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be_falsey
-      end
-
-      it "is false if queries does not match" do
-        uri = "http://app.co/aaa?pankcakes=abc"
-        client_uri = "http://app.co/aaa?waffles=abc"
-        expect(URIChecker.valid_for_authorization?(uri, client_uri)).to be false
-      end
-
-      it "calls .matches?" do
-        uri = "http://app.co/aaa?pankcakes=abc"
-        client_uri = "http://app.co/aaa?waffles=abc"
-        expect(URIChecker).to receive(:matches?).with(uri, client_uri).once
-        URIChecker.valid_for_authorization?(uri, client_uri)
-      end
-
-      it "calls .valid?" do
-        uri = "http://app.co/aaa?pankcakes=abc"
-        client_uri = "http://app.co/aaa?waffles=abc"
-        expect(URIChecker).to receive(:valid?).with(uri).once
-        URIChecker.valid_for_authorization?(uri, client_uri)
-      end
-    end
-
-    describe ".query_matches?" do
-      it "is true if no queries" do
-        expect(URIChecker.query_matches?("", "")).to be_truthy
-        expect(URIChecker.query_matches?(nil, nil)).to be_truthy
-      end
-
-      it "is true if same query" do
-        expect(URIChecker.query_matches?("foo", "foo")).to be_truthy
-      end
-
-      it "is false if different query" do
-        expect(URIChecker.query_matches?("foo", "bar")).to be_falsey
-      end
-
-      it "is true if same queries" do
-        expect(URIChecker.query_matches?("foo&bar", "foo&bar")).to be_truthy
-      end
-
-      it "is true if same queries, different order" do
-        expect(URIChecker.query_matches?("foo&bar", "bar&foo")).to be_truthy
-      end
-
-      it "is false if one different query" do
-        expect(URIChecker.query_matches?("foo&bang", "foo&bing")).to be_falsey
-      end
-
-      it "is true if same query with same value" do
-        expect(URIChecker.query_matches?("foo=bar", "foo=bar")).to be_truthy
-      end
-
-      it "is true if same queries with same values" do
-        expect(URIChecker.query_matches?("foo=bar&bing=bang", "foo=bar&bing=bang")).to be_truthy
-      end
-
-      it "is true if same queries with same values, different order" do
-        expect(URIChecker.query_matches?("foo=bar&bing=bang", "bing=bang&foo=bar")).to be_truthy
-      end
-
-      it "is false if same query with different value" do
-        expect(URIChecker.query_matches?("foo=bar", "foo=bang")).to be_falsey
-      end
-
-      it "is false if some queries missing" do
-        expect(URIChecker.query_matches?("foo=bar", "foo=bar&bing=bang")).to be_falsey
-      end
-
-      it "is false if some queries different value" do
-        expect(URIChecker.query_matches?("foo=bar&bing=bang", "foo=bar&bing=banana")).to be_falsey
-      end
-    end
-  end
-end

data/spec/lib/oauth/invalid_request_response_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Doorkeeper::OAuth::InvalidRequestResponse do
-  describe "#name" do
-    it { expect(subject.name).to eq(:invalid_request) }
-  end
-
-  describe "#status" do
-    it { expect(subject.status).to eq(:bad_request) }
-  end
-
-  describe ".from_request" do
-    let(:response) { described_class.from_request(request) }
-
-    context "missing param" do
-      let(:request) { double(missing_param: "some_param") }
-
-      it "sets a description" do
-        expect(response.description).to eq(
-          I18n.t(:missing_param, scope: %i[doorkeeper errors messages invalid_request], value: "some_param"),
-        )
-      end
-
-      it "sets the reason" do
-        expect(response.reason).to eq(:missing_param)
-      end
-    end
-
-    context "server doesn't support_pkce" do
-      let(:request) { double(invalid_request_reason: :not_support_pkce) }
-
-      it "sets a description" do
-        expect(response.description).to eq(
-          I18n.t(:not_support_pkce, scope: %i[doorkeeper errors messages invalid_request]),
-        )
-      end
-
-      it "sets the reason" do
-        expect(response.reason).to eq(:not_support_pkce)
-      end
-    end
-
-    context "request is not authorized" do
-      let(:request) { double(invalid_request_reason: :request_not_authorized) }
-
-      it "sets a description" do
-        expect(response.description).to eq(
-          I18n.t(:request_not_authorized, scope: %i[doorkeeper errors messages invalid_request]),
-        )
-      end
-
-      it "sets the reason" do
-        expect(response.reason).to eq(:request_not_authorized)
-      end
-    end
-
-    context "unknown reason" do
-      let(:request) { double(invalid_request_reason: :unknown_reason) }
-
-      it "sets a description" do
-        expect(response.description).to eq(
-          I18n.t(:unknown, scope: %i[doorkeeper errors messages invalid_request]),
-        )
-      end
-
-      it "unknown reason" do
-        expect(response.reason).to eq(:unknown_reason)
-      end
-    end
-  end
-end