doorkeeper 5.4.0.rc1 → 5.4.0

data/spec/requests/flows/refresh_token_spec.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe "Refresh Token Flow" do
-  before do
-    Doorkeeper.configure do
-      orm DOORKEEPER_ORM
-      use_refresh_token
-    end
-
-    client_exists
-  end
-
-  let(:resource_owner) { FactoryBot.create(:resource_owner) }
-
-  context "issuing a refresh token" do
-    before do
-      authorization_code_exists application: @client,
-                                resource_owner_id: resource_owner.id,
-                                resource_owner_type: resource_owner.class.name
-    end
-
-    it "client gets the refresh token and refreshes it" do
-      post token_endpoint_url(code: @authorization.token, client: @client)
-
-      token = Doorkeeper::AccessToken.first
-
-      should_have_json "access_token",  token.token
-      should_have_json "refresh_token", token.refresh_token
-
-      expect(@authorization.reload).to be_revoked
-
-      post refresh_token_endpoint_url(client: @client, refresh_token: token.refresh_token)
-
-      new_token = Doorkeeper::AccessToken.last
-      should_have_json "access_token",  new_token.token
-      should_have_json "refresh_token", new_token.refresh_token
-
-      expect(token.token).not_to         eq(new_token.token)
-      expect(token.refresh_token).not_to eq(new_token.refresh_token)
-    end
-  end
-
-  context "refreshing the token" do
-    before do
-      @token = FactoryBot.create(
-        :access_token,
-        application: @client,
-        resource_owner_id: resource_owner.id,
-        resource_owner_type: resource_owner.class.name,
-        use_refresh_token: true,
-      )
-    end
-
-    context "refresh_token revoked on use" do
-      it "client request a token with refresh token" do
-        post refresh_token_endpoint_url(
-          client: @client, refresh_token: @token.refresh_token,
-        )
-        should_have_json(
-          "refresh_token", Doorkeeper::AccessToken.last.refresh_token,
-        )
-        expect(@token.reload).not_to be_revoked
-      end
-
-      it "client request a token with expired access token" do
-        @token.update_attribute :expires_in, -100
-        post refresh_token_endpoint_url(
-          client: @client, refresh_token: @token.refresh_token,
-        )
-        should_have_json(
-          "refresh_token", Doorkeeper::AccessToken.last.refresh_token,
-        )
-        expect(@token.reload).not_to be_revoked
-      end
-    end
-
-    context "refresh_token revoked on refresh_token request" do
-      before do
-        allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(false)
-      end
-
-      it "client request a token with refresh token" do
-        post refresh_token_endpoint_url(
-          client: @client, refresh_token: @token.refresh_token,
-        )
-        should_have_json(
-          "refresh_token", Doorkeeper::AccessToken.last.refresh_token,
-        )
-        expect(@token.reload).to be_revoked
-      end
-
-      it "client request a token with expired access token" do
-        @token.update_attribute :expires_in, -100
-        post refresh_token_endpoint_url(
-          client: @client, refresh_token: @token.refresh_token,
-        )
-        should_have_json(
-          "refresh_token", Doorkeeper::AccessToken.last.refresh_token,
-        )
-        expect(@token.reload).to be_revoked
-      end
-    end
-
-    context "public & private clients" do
-      let(:public_client) do
-        FactoryBot.create(
-          :application,
-          confidential: false,
-        )
-      end
-
-      let(:token_for_private_client) do
-        FactoryBot.create(
-          :access_token,
-          application: @client,
-          resource_owner_id: resource_owner.id,
-          resource_owner_type: resource_owner.class.name,
-          use_refresh_token: true,
-        )
-      end
-
-      let(:token_for_public_client) do
-        FactoryBot.create(
-          :access_token,
-          application: public_client,
-          resource_owner_id: resource_owner.id,
-          resource_owner_type: resource_owner.class.name,
-          use_refresh_token: true,
-        )
-      end
-
-      it "issues a new token without client_secret when refresh token was issued to a public client" do
-        post refresh_token_endpoint_url(
-          client_id: public_client.uid,
-          refresh_token: token_for_public_client.refresh_token,
-        )
-
-        new_token = Doorkeeper::AccessToken.last
-        should_have_json "access_token",  new_token.token
-        should_have_json "refresh_token", new_token.refresh_token
-      end
-
-      it "returns an error without credentials" do
-        post refresh_token_endpoint_url(refresh_token: token_for_private_client.refresh_token)
-
-        should_not_have_json "refresh_token"
-        should_have_json "error", "invalid_grant"
-      end
-
-      it "returns an error with wrong credentials" do
-        post refresh_token_endpoint_url(
-          client_id: "1",
-          client_secret: "1",
-          refresh_token: token_for_private_client.refresh_token,
-        )
-
-        should_not_have_json "refresh_token"
-        should_have_json "error", "invalid_client"
-      end
-    end
-
-    it "client gets an error for invalid refresh token" do
-      post refresh_token_endpoint_url(client: @client, refresh_token: "invalid")
-      should_not_have_json "refresh_token"
-      should_have_json "error", "invalid_grant"
-    end
-
-    it "client gets an error for revoked access token" do
-      @token.revoke
-      post refresh_token_endpoint_url(client: @client, refresh_token: @token.refresh_token)
-      should_not_have_json "refresh_token"
-      should_have_json "error", "invalid_grant"
-    end
-
-    it "second of simultaneous client requests get an error for revoked access token" do
-      allow_any_instance_of(Doorkeeper::AccessToken).to receive(:revoked?).and_return(false, true)
-      post refresh_token_endpoint_url(client: @client, refresh_token: @token.refresh_token)
-
-      should_not_have_json "refresh_token"
-      should_have_json "error", "invalid_grant"
-    end
-  end
-
-  context "refreshing the token with multiple sessions (devices)" do
-    before do
-      # enable password auth to simulate other devices
-      config_is_set(:grant_flows, ["password"])
-      config_is_set(:resource_owner_from_credentials) do
-        User.authenticate! params[:username], params[:password]
-      end
-      create_resource_owner
-      _another_token = post password_token_endpoint_url(
-        client: @client, resource_owner: resource_owner,
-      )
-      last_token.update(created_at: 5.seconds.ago)
-
-      @token = FactoryBot.create(
-        :access_token,
-        application: @client,
-        resource_owner_id: resource_owner.id,
-        resource_owner_type: resource_owner.class.name,
-        use_refresh_token: true,
-      )
-      @token.update_attribute :expires_in, -100
-    end
-
-    context "refresh_token revoked on use" do
-      it "client request a token after creating another token with the same user" do
-        post refresh_token_endpoint_url(
-          client: @client, refresh_token: @token.refresh_token,
-        )
-
-        should_have_json "refresh_token", last_token.refresh_token
-        expect(@token.reload).not_to be_revoked
-      end
-    end
-
-    context "refresh_token revoked on refresh_token request" do
-      before do
-        allow(Doorkeeper::AccessToken).to receive(:refresh_token_revoked_on_use?).and_return(false)
-      end
-
-      it "client request a token after creating another token with the same user" do
-        post refresh_token_endpoint_url(
-          client: @client, refresh_token: @token.refresh_token,
-        )
-
-        should_have_json "refresh_token", last_token.refresh_token
-        expect(@token.reload).to be_revoked
-      end
-    end
-
-    def last_token
-      Doorkeeper::AccessToken.last_authorized_token_for(
-        @client.id, resource_owner,
-      )
-    end
-  end
-end

data/spec/requests/flows/revoke_token_spec.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe "Revoke Token Flow" do
-  before do
-    Doorkeeper.configure { orm DOORKEEPER_ORM }
-  end
-
-  let(:private_client_application) { FactoryBot.create :application }
-  let(:public_client_application) { FactoryBot.create :application, confidential: false }
-  let(:resource_owner) { User.create!(name: "John", password: "sekret") }
-
-  context "with authenticated, confidential OAuth 2.0 client/application" do
-    let(:access_token) do
-      FactoryBot.create(
-        :access_token,
-        application: private_client_application,
-        resource_owner_id: resource_owner.id,
-        resource_owner_type: resource_owner.class.name,
-        use_refresh_token: true,
-      )
-    end
-
-    let(:headers) do
-      client_id = private_client_application.uid
-      client_secret = private_client_application.secret
-      credentials = Base64.encode64("#{client_id}:#{client_secret}")
-      { "HTTP_AUTHORIZATION" => "Basic #{credentials}" }
-    end
-
-    it "should revoke the access token provided" do
-      post revocation_token_endpoint_url, params: { token: access_token.token }, headers: headers
-
-      expect(response).to be_successful
-      expect(access_token.reload.revoked?).to be_truthy
-    end
-
-    it "should revoke the refresh token provided" do
-      post revocation_token_endpoint_url, params: { token: access_token.refresh_token }, headers: headers
-
-      expect(response).to be_successful
-      expect(access_token.reload.revoked?).to be_truthy
-    end
-
-    context "with invalid token to revoke" do
-      it "should not revoke any tokens and must respond with success" do
-        expect do
-          post revocation_token_endpoint_url,
-               params: { token: "I_AM_AN_INVALID_TOKEN" },
-               headers: headers
-        end.not_to(change { Doorkeeper::AccessToken.where(revoked_at: nil).count })
-
-        expect(response).to be_successful
-      end
-    end
-
-    context "with bad credentials and a valid token" do
-      let(:headers) do
-        client_id = private_client_application.uid
-        credentials = Base64.encode64("#{client_id}:poop")
-        { "HTTP_AUTHORIZATION" => "Basic #{credentials}" }
-      end
-
-      it "should not revoke any tokens and respond with forbidden" do
-        post revocation_token_endpoint_url, params: { token: access_token.token }, headers: headers
-
-        expect(response).to be_forbidden
-        expect(response.body).to include("unauthorized_client")
-        expect(response.body).to include(I18n.t("doorkeeper.errors.messages.revoke.unauthorized"))
-        expect(access_token.reload.revoked?).to be_falsey
-      end
-    end
-
-    context "with no credentials and a valid token" do
-      it "should not revoke any tokens and respond with forbidden" do
-        post revocation_token_endpoint_url, params: { token: access_token.token }
-
-        expect(response).to be_forbidden
-        expect(response.body).to include("unauthorized_client")
-        expect(response.body).to include(I18n.t("doorkeeper.errors.messages.revoke.unauthorized"))
-        expect(access_token.reload.revoked?).to be_falsey
-      end
-    end
-
-    context "with valid token for another client application" do
-      let(:other_client_application) { FactoryBot.create :application }
-      let(:headers) do
-        client_id = other_client_application.uid
-        client_secret = other_client_application.secret
-        credentials = Base64.encode64("#{client_id}:#{client_secret}")
-        { "HTTP_AUTHORIZATION" => "Basic #{credentials}" }
-      end
-
-      it "should not revoke the token as it's unauthorized" do
-        post revocation_token_endpoint_url, params: { token: access_token.token }, headers: headers
-
-        expect(response).to be_forbidden
-        expect(response.body).to include("unauthorized_client")
-        expect(response.body).to include(I18n.t("doorkeeper.errors.messages.revoke.unauthorized"))
-        expect(access_token.reload.revoked?).to be_falsey
-      end
-    end
-  end
-
-  context "with authenticated public OAuth 2.0 client/application" do
-    let(:access_token) do
-      FactoryBot.create(
-        :access_token,
-        application: nil,
-        resource_owner_id: resource_owner.id,
-        resource_owner_type: resource_owner.class.name,
-        use_refresh_token: true,
-      )
-    end
-
-    it "should revoke the access token provided" do
-      post revocation_token_endpoint_url,
-           params: { client_id: public_client_application.uid, token: access_token.token },
-           headers: headers
-
-      expect(response).to be_successful
-      expect(access_token.reload.revoked?).to be_truthy
-    end
-
-    it "should revoke the refresh token provided" do
-      post revocation_token_endpoint_url,
-           params: { client_id: public_client_application.uid, token: access_token.refresh_token },
-           headers: headers
-
-      expect(response).to be_successful
-      expect(access_token.reload.revoked?).to be_truthy
-    end
-
-    it "should response with success even for invalid token" do
-      post revocation_token_endpoint_url,
-           params: { client_id: public_client_application.uid, token: "dont_exist" },
-           headers: headers
-
-      expect(response).to be_successful
-    end
-
-    context "with a valid token issued for a confidential client" do
-      let(:access_token) do
-        FactoryBot.create(
-          :access_token,
-          application: private_client_application,
-          resource_owner_id: resource_owner.id,
-          resource_owner_type: resource_owner.class.name,
-          use_refresh_token: true,
-        )
-      end
-
-      it "should not revoke the access token provided" do
-        post revocation_token_endpoint_url,
-             params: { client_id: public_client_application.uid, token: access_token.token }
-
-        expect(response).to be_forbidden
-        expect(response.body).to include("unauthorized_client")
-        expect(response.body).to include(I18n.t("doorkeeper.errors.messages.revoke.unauthorized"))
-        expect(access_token.reload.revoked?).to be_falsey
-      end
-
-      it "should not revoke the refresh token provided" do
-        post revocation_token_endpoint_url,
-             params: { client_id: public_client_application.uid, token: access_token.token }
-
-        expect(response).to be_forbidden
-        expect(response.body).to include("unauthorized_client")
-        expect(response.body).to include(I18n.t("doorkeeper.errors.messages.revoke.unauthorized"))
-        expect(access_token.reload.revoked?).to be_falsey
-      end
-    end
-  end
-
-  context "without client authentication" do
-    let(:access_token) do
-      FactoryBot.create(
-        :access_token,
-        application: nil,
-        resource_owner_id: resource_owner.id,
-        resource_owner_type: resource_owner.class.name,
-        use_refresh_token: true,
-      )
-    end
-
-    it "shouldn't remove the token and must response with an error" do
-      post revocation_token_endpoint_url,
-           params: { token: access_token.token },
-           headers: headers
-
-      expect(response).not_to be_successful
-      expect(access_token.reload.revoked?).to be_falsey
-    end
-  end
-end

data/spec/requests/flows/skip_authorization_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-feature "Skip authorization form" do
-  background do
-    config_is_set(:authenticate_resource_owner) { User.first || redirect_to("/sign_in") }
-    client_exists
-    default_scopes_exist  :public
-    optional_scopes_exist :write
-  end
-
-  context "for previously authorized clients" do
-    background do
-      create_resource_owner
-      sign_in
-    end
-
-    scenario "skips the authorization and return a new grant code" do
-      client_is_authorized(@client, @resource_owner, scopes: "public")
-      visit authorization_endpoint_url(client: @client, scope: "public")
-
-      i_should_not_see "Authorize"
-      client_should_be_authorized @client
-      i_should_be_on_client_callback @client
-      url_should_have_param "code", Doorkeeper::AccessGrant.first.token
-    end
-
-    scenario "skips the authorization if other scopes are not requested" do
-      client_exists scopes: "public read write"
-      client_is_authorized(@client, @resource_owner, scopes: "public")
-      visit authorization_endpoint_url(client: @client, scope: "public")
-
-      i_should_not_see "Authorize"
-      client_should_be_authorized @client
-      i_should_be_on_client_callback @client
-      url_should_have_param "code", Doorkeeper::AccessGrant.first.token
-    end
-
-    scenario "does not skip authorization when scopes differ (new request has fewer scopes)" do
-      client_is_authorized(@client, @resource_owner, scopes: "public write")
-      visit authorization_endpoint_url(client: @client, scope: "public")
-      i_should_see "Authorize"
-    end
-
-    scenario "does not skip authorization when scopes differ (new request has more scopes)" do
-      client_is_authorized(@client, @resource_owner, scopes: "public write")
-      visit authorization_endpoint_url(client: @client, scopes: "public write email")
-      i_should_see "Authorize"
-    end
-
-    scenario "creates grant with new scope when scopes differ" do
-      client_is_authorized(@client, @resource_owner, scopes: "public write")
-      visit authorization_endpoint_url(client: @client, scope: "public")
-      click_on "Authorize"
-      access_grant_should_have_scopes :public
-    end
-
-    scenario "creates grant with new scope when scopes are greater" do
-      client_is_authorized(@client, @resource_owner, scopes: "public")
-      visit authorization_endpoint_url(client: @client, scope: "public write")
-      click_on "Authorize"
-      access_grant_should_have_scopes :public, :write
-    end
-  end
-end

data/spec/requests/protected_resources/metal_spec.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe "ActionController::Metal API" do
-  before do
-    @client   = FactoryBot.create(:application)
-    @resource = User.create!(name: "Joe", password: "sekret")
-    @token    = client_is_authorized(@client, @resource)
-  end
-
-  it "client requests protected resource with valid token" do
-    get "/metal.json?access_token=#{@token.token}"
-    should_have_json "ok", true
-  end
-end

data/spec/requests/protected_resources/private_api_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-feature "Private API" do
-  background do
-    @client   = FactoryBot.create(:application)
-    @resource = User.create!(name: "Joe", password: "sekret")
-    @token    = client_is_authorized(@client, @resource)
-  end
-
-  scenario "client requests protected resource with valid token" do
-    with_access_token_header @token.token
-    visit "/full_protected_resources"
-    expect(page.body).to have_content("index")
-  end
-
-  scenario "client requests protected resource with disabled header authentication" do
-    config_is_set :access_token_methods, [:from_access_token_param]
-    with_access_token_header @token.token
-    visit "/full_protected_resources"
-    response_status_should_be 401
-  end
-
-  scenario "client attempts to request protected resource with invalid token" do
-    with_access_token_header "invalid"
-    visit "/full_protected_resources"
-    response_status_should_be 401
-  end
-
-  scenario "client attempts to request protected resource with expired token" do
-    @token.update_attribute :expires_in, -100 # expires token
-    with_access_token_header @token.token
-    visit "/full_protected_resources"
-    response_status_should_be 401
-  end
-
-  scenario "client requests protected resource with permanent token" do
-    @token.update_attribute :expires_in, nil # never expires
-    with_access_token_header @token.token
-    visit "/full_protected_resources"
-    expect(page.body).to have_content("index")
-  end
-
-  scenario "access token with no default scopes" do
-    Doorkeeper.configuration.instance_eval do
-      @default_scopes = Doorkeeper::OAuth::Scopes.from_array([:public])
-      @scopes = default_scopes + optional_scopes
-    end
-    @token.update_attribute :scopes, "dummy"
-    with_access_token_header @token.token
-    visit "/full_protected_resources"
-    response_status_should_be 403
-  end
-
-  scenario "access token with no allowed scopes" do
-    @token.update_attribute :scopes, nil
-    with_access_token_header @token.token
-    visit "/full_protected_resources/1.json"
-    response_status_should_be 403
-  end
-
-  scenario "access token with one of allowed scopes" do
-    @token.update_attribute :scopes, "admin"
-    with_access_token_header @token.token
-    visit "/full_protected_resources/1.json"
-    expect(page.body).to have_content("show")
-  end
-
-  scenario "access token with another of allowed scopes" do
-    @token.update_attribute :scopes, "write"
-    with_access_token_header @token.token
-    visit "/full_protected_resources/1.json"
-    expect(page.body).to have_content("show")
-  end
-
-  scenario "access token with both allowed scopes" do
-    @token.update_attribute :scopes, "write admin"
-    with_access_token_header @token.token
-    visit "/full_protected_resources/1.json"
-    expect(page.body).to have_content("show")
-  end
-end