doorkeeper 5.2.6 → 5.3.0

data/spec/lib/oauth/refresh_token_request_spec.rb

@@ -2,177 +2,176 @@
 
 require "spec_helper"
 
-module Doorkeeper::OAuth
-  describe RefreshTokenRequest do
-    let(:server) do
-      double :server,
-             access_token_expires_in: 2.minutes
-    end
+describe Doorkeeper::OAuth::RefreshTokenRequest do
+  let(:server) do
+    double :server,
+           access_token_expires_in: 2.minutes
+  end
 
-    let(:refresh_token) do
-      FactoryBot.create(:access_token, use_refresh_token: true)
-    end
+  let(:refresh_token) do
+    FactoryBot.create(:access_token, use_refresh_token: true)
+  end
 
-    let(:client) { refresh_token.application }
-    let(:credentials) { Client::Credentials.new(client.uid, client.secret) }
+  let(:client) { refresh_token.application }
+  let(:credentials) { Doorkeeper::OAuth::Client::Credentials.new(client.uid, client.secret) }
 
-    before do
-      allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(false)
-      allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(false)
-    end
+  before do
+    allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(false)
+    allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(false)
+  end
 
-    subject { RefreshTokenRequest.new server, refresh_token, credentials }
+  subject { described_class.new server, refresh_token, credentials }
 
-    it "issues a new token for the client" do
-      expect { subject.authorize }.to change { client.reload.access_tokens.count }.by(1)
-      # #sort_by used for MongoDB ORM extensions for valid ordering
-      expect(client.reload.access_tokens.max_by(&:created_at).expires_in).to eq(120)
-    end
+  it "issues a new token for the client" do
+    expect { subject.authorize }.to change { client.reload.access_tokens.count }.by(1)
+    # #sort_by used for MongoDB ORM extensions for valid ordering
+    expect(client.reload.access_tokens.max_by(&:created_at).expires_in).to eq(120)
+  end
 
-    it "issues a new token for the client with custom expires_in" do
-      server = double :server,
-                      access_token_expires_in: 2.minutes,
-                      custom_access_token_expires_in: lambda { |context|
-                        context.grant_type == Doorkeeper::OAuth::REFRESH_TOKEN ? 1234 : nil
-                      }
+  it "issues a new token for the client with custom expires_in" do
+    server = double :server,
+                    access_token_expires_in: 2.minutes,
+                    custom_access_token_expires_in: lambda { |context|
+                      context.grant_type == Doorkeeper::OAuth::REFRESH_TOKEN ? 1234 : nil
+                    }
 
-      allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
-      allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(false)
+    allow(server).to receive(:option_defined?).with(:custom_access_token_expires_in).and_return(true)
+    allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(false)
 
-      RefreshTokenRequest.new(server, refresh_token, credentials).authorize
+    described_class.new(server, refresh_token, credentials).authorize
 
-      # #sort_by used for MongoDB ORM extensions for valid ordering
-      expect(client.reload.access_tokens.max_by(&:created_at).expires_in).to eq(1234)
-    end
+    # #sort_by used for MongoDB ORM extensions for valid ordering
+    expect(client.reload.access_tokens.max_by(&:created_at).expires_in).to eq(1234)
+  end
+
+  it "revokes the previous token" do
+    expect { subject.authorize }.to change { refresh_token.revoked? }.from(false).to(true)
+  end
+
+  it "calls configured request callback methods" do
+    expect(Doorkeeper.configuration.before_successful_strategy_response)
+      .to receive(:call).with(subject).once
+
+    expect(Doorkeeper.configuration.after_successful_strategy_response)
+      .to receive(:call).with(subject, instance_of(Doorkeeper::OAuth::TokenResponse)).once
+
+    subject.authorize
+  end
+
+  it "requires the refresh token" do
+    subject.refresh_token = nil
+    subject.validate
+    expect(subject.error).to eq(:invalid_request)
+    expect(subject.missing_param).to eq(:refresh_token)
+  end
+
+  it "requires credentials to be valid if provided" do
+    subject.client = nil
+    subject.validate
+    expect(subject.error).to eq(:invalid_client)
+  end
+
+  it "requires the token's client and current client to match" do
+    subject.client = FactoryBot.create(:application)
+    subject.validate
+    expect(subject.error).to eq(:invalid_grant)
+  end
+
+  it "rejects revoked tokens" do
+    refresh_token.revoke
+    subject.validate
+    expect(subject.error).to eq(:invalid_grant)
+  end
+
+  it "accepts expired tokens" do
+    refresh_token.expires_in = -1
+    refresh_token.save
+    subject.validate
+    expect(subject).to be_valid
+  end
 
-    it "revokes the previous token" do
-      expect { subject.authorize }.to change { refresh_token.revoked? }.from(false).to(true)
+  context "refresh tokens expire on access token use" do
+    let(:server) do
+      double :server,
+             access_token_expires_in: 2.minutes,
+             custom_access_token_expires_in: lambda { |context|
+               context.grant_type == Doorkeeper::OAuth::REFRESH_TOKEN ? 1234 : nil
+             }
     end
 
-    it "calls configured request callback methods" do
-      expect(Doorkeeper.configuration.before_successful_strategy_response)
-        .to receive(:call).with(subject).once
+    before do
+      allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(true)
+    end
 
-      expect(Doorkeeper.configuration.after_successful_strategy_response)
-        .to receive(:call).with(subject, instance_of(Doorkeeper::OAuth::TokenResponse)).once
+    it "issues a new token for the client" do
+      expect { subject.authorize }.to change { client.reload.access_tokens.count }.by(1)
+    end
 
+    it "does not revoke the previous token" do
       subject.authorize
+      expect(refresh_token).not_to be_revoked
     end
 
-    it "requires the refresh token" do
-      subject.refresh_token = nil
-      subject.validate
-      expect(subject.error).to eq(:invalid_request)
-      expect(subject.missing_param).to eq(:refresh_token)
+    it "sets the previous refresh token in the new access token" do
+      subject.authorize
+      expect(
+        # #sort_by used for MongoDB ORM extensions for valid ordering
+        client.access_tokens.max_by(&:created_at).previous_refresh_token,
+      ).to eq(refresh_token.refresh_token)
     end
+  end
 
-    it "requires credentials to be valid if provided" do
-      subject.client = nil
-      subject.validate
-      expect(subject.error).to eq(:invalid_client)
-    end
+  context "clientless access tokens" do
+    let!(:refresh_token) { FactoryBot.create(:clientless_access_token, use_refresh_token: true) }
 
-    it "requires the token's client and current client to match" do
-      subject.client = FactoryBot.create(:application)
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
+    subject { described_class.new server, refresh_token, nil }
+
+    it "issues a new token without a client" do
+      expect { subject.authorize }.to change { Doorkeeper::AccessToken.count }.by(1)
     end
+  end
 
-    it "rejects revoked tokens" do
-      refresh_token.revoke
-      subject.validate
-      expect(subject.error).to eq(:invalid_grant)
+  context "with scopes" do
+    let(:refresh_token) do
+      FactoryBot.create :access_token,
+                        use_refresh_token: true,
+                        scopes: "public write"
     end
+    let(:parameters) { {} }
 
-    it "accepts expired tokens" do
-      refresh_token.expires_in = -1
-      refresh_token.save
-      subject.validate
-      expect(subject).to be_valid
+    subject { described_class.new server, refresh_token, credentials, parameters }
+
+    it "transfers scopes from the old token to the new token" do
+      subject.authorize
+      expect(Doorkeeper::AccessToken.last.scopes).to eq(%i[public write])
     end
 
-    context "refresh tokens expire on access token use" do
-      let(:server) do
-        double :server,
-               access_token_expires_in: 2.minutes,
-               custom_access_token_expires_in: lambda { |context|
-                 context.grant_type == Doorkeeper::OAuth::REFRESH_TOKEN ? 1234 : nil
-               }
-      end
-
-      before do
-        allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(true)
-      end
-
-      it "issues a new token for the client" do
-        expect { subject.authorize }.to change { client.reload.access_tokens.count }.by(1)
-      end
-
-      it "does not revoke the previous token" do
-        subject.authorize
-        expect(refresh_token).not_to be_revoked
-      end
-
-      it "sets the previous refresh token in the new access token" do
-        subject.authorize
-        expect(
-          # #sort_by used for MongoDB ORM extensions for valid ordering
-          client.access_tokens.max_by(&:created_at).previous_refresh_token
-        ).to eq(refresh_token.refresh_token)
-      end
+    it "reduces scopes to the provided scopes" do
+      parameters[:scopes] = "public"
+      subject.authorize
+      expect(Doorkeeper::AccessToken.last.scopes).to eq(%i[public])
     end
 
-    context "clientless access tokens" do
-      let!(:refresh_token) { FactoryBot.create(:clientless_access_token, use_refresh_token: true) }
+    it "validates that scopes are included in the original access token" do
+      parameters[:scopes] = "public update"
 
-      subject { RefreshTokenRequest.new server, refresh_token, nil }
+      subject.validate
+      expect(subject.error).to eq(:invalid_scope)
+    end
 
-      it "issues a new token without a client" do
-        expect { subject.authorize }.to change { Doorkeeper::AccessToken.count }.by(1)
-      end
+    it "uses params[:scope] in favor of scopes if present (valid)" do
+      parameters[:scopes] = "public update"
+      parameters[:scope] = "public"
+      subject.authorize
+      expect(Doorkeeper::AccessToken.last.scopes).to eq(%i[public])
     end
 
-    context "with scopes" do
-      let(:refresh_token) do
-        FactoryBot.create :access_token,
-                          use_refresh_token: true,
-                          scopes: "public write"
-      end
-      let(:parameters) { {} }
-      subject { RefreshTokenRequest.new server, refresh_token, credentials, parameters }
-
-      it "transfers scopes from the old token to the new token" do
-        subject.authorize
-        expect(Doorkeeper::AccessToken.last.scopes).to eq(%i[public write])
-      end
-
-      it "reduces scopes to the provided scopes" do
-        parameters[:scopes] = "public"
-        subject.authorize
-        expect(Doorkeeper::AccessToken.last.scopes).to eq(%i[public])
-      end
-
-      it "validates that scopes are included in the original access token" do
-        parameters[:scopes] = "public update"
-
-        subject.validate
-        expect(subject.error).to eq(:invalid_scope)
-      end
-
-      it "uses params[:scope] in favor of scopes if present (valid)" do
-        parameters[:scopes] = "public update"
-        parameters[:scope] = "public"
-        subject.authorize
-        expect(Doorkeeper::AccessToken.last.scopes).to eq(%i[public])
-      end
-
-      it "uses params[:scope] in favor of scopes if present (invalid)" do
-        parameters[:scopes] = "public"
-        parameters[:scope] = "public update"
-
-        subject.validate
-        expect(subject.error).to eq(:invalid_scope)
-      end
+    it "uses params[:scope] in favor of scopes if present (invalid)" do
+      parameters[:scopes] = "public"
+      parameters[:scope] = "public update"
+
+      subject.validate
+      expect(subject.error).to eq(:invalid_scope)
     end
   end
 end

data/spec/lib/oauth/scopes_spec.rb

@@ -2,147 +2,145 @@
 
 require "spec_helper"
 
-module Doorkeeper::OAuth
-  describe Scopes do
-    describe "#add" do
-      it "allows you to add scopes with symbols" do
-        subject.add :public
-        expect(subject.all).to eq(["public"])
-      end
+describe Doorkeeper::OAuth::Scopes do
+  describe "#add" do
+    it "allows you to add scopes with symbols" do
+      subject.add :public
+      expect(subject.all).to eq(["public"])
+    end
 
-      it "allows you to add scopes with strings" do
-        subject.add "public"
-        expect(subject.all).to eq(["public"])
-      end
+    it "allows you to add scopes with strings" do
+      subject.add "public"
+      expect(subject.all).to eq(["public"])
+    end
 
-      it "do not add already included scopes" do
-        subject.add :public
-        subject.add :public
-        expect(subject.all).to eq(["public"])
-      end
+    it "do not add already included scopes" do
+      subject.add :public
+      subject.add :public
+      expect(subject.all).to eq(["public"])
     end
+  end
 
-    describe "#exists" do
-      before do
-        subject.add :public
-      end
+  describe "#exists" do
+    before do
+      subject.add :public
+    end
 
-      it "returns true if scope with given name is present" do
-        expect(subject.exists?("public")).to be_truthy
-      end
+    it "returns true if scope with given name is present" do
+      expect(subject.exists?("public")).to be_truthy
+    end
 
-      it "returns false if scope with given name does not exist" do
-        expect(subject.exists?("other")).to be_falsey
-      end
+    it "returns false if scope with given name does not exist" do
+      expect(subject.exists?("other")).to be_falsey
+    end
 
-      it "handles symbols" do
-        expect(subject.exists?(:public)).to be_truthy
-        expect(subject.exists?(:other)).to be_falsey
-      end
+    it "handles symbols" do
+      expect(subject.exists?(:public)).to be_truthy
+      expect(subject.exists?(:other)).to be_falsey
     end
+  end
 
-    describe ".from_string" do
-      let(:string) { "public write" }
+  describe ".from_string" do
+    let(:string) { "public write" }
 
-      subject { Scopes.from_string(string) }
+    subject { described_class.from_string(string) }
 
-      it { expect(subject).to be_a(Scopes) }
+    it { expect(subject).to be_a(described_class) }
 
-      describe "#all" do
-        it "should be an array of the expected scopes" do
-          scopes_array = subject.all
-          expect(scopes_array.size).to eq(2)
-          expect(scopes_array).to include("public")
-          expect(scopes_array).to include("write")
-        end
+    describe "#all" do
+      it "should be an array of the expected scopes" do
+        scopes_array = subject.all
+        expect(scopes_array.size).to eq(2)
+        expect(scopes_array).to include("public")
+        expect(scopes_array).to include("write")
       end
     end
+  end
 
-    describe "#+" do
-      it "can add to another scope object" do
-        scopes = Scopes.from_string("public") + Scopes.from_string("admin")
-        expect(scopes.all).to eq(%w[public admin])
-      end
+  describe "#+" do
+    it "can add to another scope object" do
+      scopes = described_class.from_string("public") + described_class.from_string("admin")
+      expect(scopes.all).to eq(%w[public admin])
+    end
 
-      it "does not change the existing object" do
-        origin = Scopes.from_string("public")
-        expect(origin.to_s).to eq("public")
-      end
+    it "does not change the existing object" do
+      origin = described_class.from_string("public")
+      expect(origin.to_s).to eq("public")
+    end
 
-      it "can add an array to a scope object" do
-        scopes = Scopes.from_string("public") + ["admin"]
-        expect(scopes.all).to eq(%w[public admin])
-      end
+    it "can add an array to a scope object" do
+      scopes = described_class.from_string("public") + ["admin"]
+      expect(scopes.all).to eq(%w[public admin])
+    end
 
-      it "raises an error if cannot handle addition" do
-        expect do
-          Scopes.from_string("public") + "admin"
-        end.to raise_error(NoMethodError)
-      end
+    it "raises an error if cannot handle addition" do
+      expect do
+        described_class.from_string("public") + "admin"
+      end.to raise_error(NoMethodError)
     end
+  end
 
-    describe "#&" do
-      it "can get intersection with another scope object" do
-        scopes = Scopes.from_string("public admin") & Scopes.from_string("write admin")
-        expect(scopes.all).to eq(%w[admin])
-      end
+  describe "#&" do
+    it "can get intersection with another scope object" do
+      scopes = described_class.from_string("public admin") & described_class.from_string("write admin")
+      expect(scopes.all).to eq(%w[admin])
+    end
 
-      it "does not change the existing object" do
-        origin = Scopes.from_string("public admin")
-        origin & Scopes.from_string("write admin")
-        expect(origin.to_s).to eq("public admin")
-      end
+    it "does not change the existing object" do
+      origin = described_class.from_string("public admin")
+      origin & described_class.from_string("write admin")
+      expect(origin.to_s).to eq("public admin")
+    end
 
-      it "can get intersection with an array" do
-        scopes = Scopes.from_string("public admin") & %w[write admin]
-        expect(scopes.all).to eq(%w[admin])
-      end
+    it "can get intersection with an array" do
+      scopes = described_class.from_string("public admin") & %w[write admin]
+      expect(scopes.all).to eq(%w[admin])
     end
+  end
 
-    describe "#==" do
-      it "is equal to another set of scopes" do
-        expect(Scopes.from_string("public")).to eq(Scopes.from_string("public"))
-      end
+  describe "#==" do
+    it "is equal to another set of scopes" do
+      expect(described_class.from_string("public")).to eq(described_class.from_string("public"))
+    end
 
-      it "is equal to another set of scopes with no particular order" do
-        expect(Scopes.from_string("public write")).to eq(Scopes.from_string("write public"))
-      end
+    it "is equal to another set of scopes with no particular order" do
+      expect(described_class.from_string("public write")).to eq(described_class.from_string("write public"))
+    end
 
-      it "differs from another set of scopes when scopes are not the same" do
-        expect(Scopes.from_string("public write")).not_to eq(Scopes.from_string("write"))
-      end
+    it "differs from another set of scopes when scopes are not the same" do
+      expect(described_class.from_string("public write")).not_to eq(described_class.from_string("write"))
+    end
 
-      it "does not raise an error when compared to a non-enumerable object" do
-        expect { Scopes.from_string("public") == false }.not_to raise_error
-      end
+    it "does not raise an error when compared to a non-enumerable object" do
+      expect { described_class.from_string("public") == false }.not_to raise_error
     end
+  end
 
-    describe "#has_scopes?" do
-      subject { Scopes.from_string("public admin") }
+  describe "#has_scopes?" do
+    subject { described_class.from_string("public admin") }
 
-      it "returns true when at least one scope is included" do
-        expect(subject.has_scopes?(Scopes.from_string("public"))).to be_truthy
-      end
+    it "returns true when at least one scope is included" do
+      expect(subject.has_scopes?(described_class.from_string("public"))).to be_truthy
+    end
 
-      it "returns true when all scopes are included" do
-        expect(subject.has_scopes?(Scopes.from_string("public admin"))).to be_truthy
-      end
+    it "returns true when all scopes are included" do
+      expect(subject.has_scopes?(described_class.from_string("public admin"))).to be_truthy
+    end
 
-      it "is true if all scopes are included in any order" do
-        expect(subject.has_scopes?(Scopes.from_string("admin public"))).to be_truthy
-      end
+    it "is true if all scopes are included in any order" do
+      expect(subject.has_scopes?(described_class.from_string("admin public"))).to be_truthy
+    end
 
-      it "is false if no scopes are included" do
-        expect(subject.has_scopes?(Scopes.from_string("notexistent"))).to be_falsey
-      end
+    it "is false if no scopes are included" do
+      expect(subject.has_scopes?(described_class.from_string("notexistent"))).to be_falsey
+    end
 
-      it "returns false when any scope is not included" do
-        expect(subject.has_scopes?(Scopes.from_string("public nope"))).to be_falsey
-      end
+    it "returns false when any scope is not included" do
+      expect(subject.has_scopes?(described_class.from_string("public nope"))).to be_falsey
+    end
 
-      it "is false if no scopes are included even for existing ones" do
-        expect(subject.has_scopes?(Scopes.from_string("public admin notexistent"))).to be_falsey
-      end
+    it "is false if no scopes are included even for existing ones" do
+      expect(subject.has_scopes?(described_class.from_string("public admin notexistent"))).to be_falsey
     end
   end
 end