doorkeeper_sso 0.1.0.pre.alpha → 0.2.0

data/spec/fabricators/sso_client_fabricator.rb

@@ -0,0 +1,5 @@
+Fabricator('Sso::Client') do
+  application_id { 0 }
+  ip { "127.0.0.1" }
+  agent { "Mozilla Firefox" }
+end

data/spec/fabricators/sso_session_fabricator.rb

@@ -1,6 +1,5 @@
 Fabricator('Sso::Session') do
   application_id { 0 }
-  ip { "127.0.0.1" }
-  agent { "Mozilla Firefox" }
   owner { Fabricate(:user) }
+  clients { [ Fabricate('Sso::Client') ] }
 end

data/spec/fabricators/user_fabricator.rb

@@ -1,7 +1,9 @@
 Fabricator(:user) do
-  first_name Faker::Name.name
-  email Faker::Internet.email
-  password Faker::Internet.password
+  first_name { FFaker::Name.name }
+  last_name { FFaker::Name.last_name }
+  name { |attrs| [attrs[:first_name], attrs[:last_name]].join(" ") }
+  email { FFaker::Internet.email }
+  password { FFaker::Internet.password }
   password_confirmation { |attrs| "#{attrs[:password]}" }
 end
 

data/spec/lib/doorkeeper/access_grant_mixin_spec.rb

@@ -0,0 +1,29 @@
+require 'rails_helper'
+
+# Engine.rb automatically includes the mixin
+
+RSpec.describe Doorkeeper::AccessGrant, :type => :model do
+  describe "associations" do
+    it { is_expected.to have_one(:sso_client).class_name('Sso::Client').with_foreign_key(:access_grant_id) }
+  end
+
+  describe "assignment" do
+    let(:user) { Fabricate(:user) }
+    let(:application) { Fabricate('Doorkeeper::Application') }
+    let(:access_token) { Fabricate('Doorkeeper::AccessToken',
+                                   resource_owner_id: user.id) }
+    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+                                   application_id: application.id,
+                                   resource_owner_id: user.id,
+                                   redirect_uri: 'http://localhost:3002/oauth/callback'
+                                  ) }
+
+    let(:session) {  Fabricate('Sso::Session', owner: user) }
+    let!(:client) {  Fabricate('Sso::Client', session: session,
+                                  application_id: application.id,
+                                  access_token_id: access_token.id,
+                                  access_grant_id: access_grant.id) }
+
+    it { expect(access_grant.sso_client).to eq client }
+  end
+end

data/spec/lib/doorkeeper/access_token_mixin_spec.rb

@@ -0,0 +1,29 @@
+require 'rails_helper'
+
+# Engine.rb automatically includes the mixin
+
+RSpec.describe Doorkeeper::AccessToken, :type => :model do
+  describe "associations" do
+    it { is_expected.to have_one(:sso_client).class_name('Sso::Client').with_foreign_key(:access_token_id) }
+  end
+
+  describe "assignment" do
+    let(:user) { Fabricate(:user) }
+    let(:application) { Fabricate('Doorkeeper::Application') }
+    let(:access_token) { Fabricate('Doorkeeper::AccessToken',
+                                   resource_owner_id: user.id) }
+    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+                                   application_id: application.id,
+                                   resource_owner_id: user.id,
+                                   redirect_uri: 'http://localhost:3002/oauth/callback'
+                                  ) }
+
+    let(:session) {  Fabricate('Sso::Session', owner: user) }
+    let!(:client) {  Fabricate('Sso::Client', session: session,
+                                  application_id: application.id,
+                                  access_token_id: access_token.id,
+                                  access_grant_id: access_grant.id) }
+
+    it { expect(access_token.sso_client).to eq client }
+  end
+end

data/spec/lib/doorkeeper/application_mixin_spec.rb

@@ -0,0 +1,29 @@
+require 'rails_helper'
+
+# Engine.rb automatically includes the mixin
+
+RSpec.describe Doorkeeper::Application, :type => :model do
+  describe "associations" do
+    it { is_expected.to have_many(:sso_clients).class_name('Sso::Client').with_foreign_key(:application_id) }
+  end
+
+  describe "assignment" do
+    let(:user) { Fabricate(:user) }
+    let(:application) { Fabricate('Doorkeeper::Application') }
+    let(:access_token) { Fabricate('Doorkeeper::AccessToken',
+                                   resource_owner_id: user.id) }
+    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+                                   application_id: application.id,
+                                   resource_owner_id: user.id,
+                                   redirect_uri: 'http://localhost:3002/oauth/callback'
+                                  ) }
+
+    let(:session) {  Fabricate('Sso::Session', owner: user) }
+    let!(:client) {  Fabricate('Sso::Client', session: session,
+                                  application_id: application.id,
+                                  access_token_id: access_token.id,
+                                  access_grant_id: access_grant.id) }
+
+    it { expect(application.sso_clients).to eq [ client ] }
+  end
+end

data/spec/lib/sso/warden/hooks/after_authentication_spec.rb

@@ -0,0 +1,37 @@
+require 'rails_helper'
+
+RSpec.describe Sso::Warden::Hooks::AfterAuthentication do
+  #include Warden::Test::Helpers
+
+  let(:user) { Fabricate(:user) }
+  let(:warden_mock) { double }
+  let(:attributes) { { :ip => "202.188.0.133", :agent => "Chrome", format: :json } }
+
+  let(:after_authentication) { Sso::Warden::Hooks::AfterAuthentication.
+                               new(user: user, warden: warden_mock, options: {} ) }
+
+
+  let(:master_sso_session) { Sso::Session.generate_master(user, attributes) }
+  let(:access_token) { Fabricate("Doorkeeper::AccessToken",
+                                 resource_owner_id: user.id) }
+  let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+                                 resource_owner_id: user.id,
+                                 redirect_uri: 'http://localhost:3002/oauth/callback'
+                                ) }
+
+  before do
+    master_sso_session.access_token_id = access_token.id
+    master_sso_session.access_grant_id = access_grant.id
+    master_sso_session.save
+  end
+
+  describe 'attributes' do
+    it do
+      expect(after_authentication.user).to eq user
+      expect(after_authentication.warden).to eq warden_mock
+      expect(after_authentication.options).to eq({})
+    end
+  end
+
+  pending "#call"
+end

data/spec/lib/sso/warden/hooks/before_logout_spec.rb

@@ -0,0 +1,30 @@
+require 'rails_helper'
+
+RSpec.describe Sso::Warden::Hooks::BeforeLogout do
+
+  let(:proc)     { described_class.to_proc }
+  let(:calling)  { proc.call(user, warden, options) }
+  let(:user)     { double :user }
+  let(:params)   { { passport_id: 1337 } } #passport.id } }
+  let(:options)  { double :options }
+  let(:request)  { double :request, params: params.stringify_keys }
+  let(:warden)   { double :warden, request: request, :session => user }
+
+  before do
+    allow(warden).to receive(:authenticated?)
+    Timecop.freeze
+  end
+
+  describe '.to_proc' do
+    it 'is a proc' do
+      expect(proc).to be_instance_of Proc
+    end
+  end
+
+  describe '#call' do
+    it 'accepts the three warden arguments and returns nothing' do
+      expect(calling).to be_nil
+    end
+  end
+
+end

data/spec/models/sso/client_spec.rb

@@ -0,0 +1,15 @@
+require 'rails_helper'
+
+RSpec.describe Sso::Client, :type => :model do
+  describe "associations" do
+    it { is_expected.to belong_to(:session).class_name('Sso::Session').with_foreign_key(:sso_session_id) }
+    it { is_expected.to belong_to(:application).class_name('Doorkeeper::Application') }
+    it { is_expected.to belong_to(:access_grant).class_name('Doorkeeper::AccessGrant') }
+    it { is_expected.to belong_to(:access_token).class_name('Doorkeeper::AccessToken') }
+  end
+
+  describe "validations" do
+    it { is_expected.to validate_uniqueness_of(:access_grant_id).allow_nil }
+    it { is_expected.to validate_uniqueness_of(:access_token_id).allow_nil }
+  end
+end

data/spec/models/sso/session_spec.rb

@@ -6,12 +6,11 @@ RSpec.describe Sso::Session, :type => :model do
     it { is_expected.to belong_to(:access_grant).class_name('Doorkeeper::AccessGrant') }
     it { is_expected.to belong_to(:access_token).class_name('Doorkeeper::AccessToken') }
     it { is_expected.to belong_to(:owner).class_name('User') }
+    it { is_expected.to have_many(:clients).class_name('Sso::Client').with_foreign_key(:sso_session_id) }
   end
 
   describe "validations" do
-    pending { is_expected.to validate_presence_of(:group_id) }
     pending { is_expected.to validate_presence_of(:secret) }
-    pending { is_expected.to validate_uniqueness_of(:access_token_id).scoped_to([:owner_id, :revoked_at, :application_id]) }
     it { is_expected.to allow_value(nil).for(:access_token_id) }
   end
 
@@ -21,6 +20,36 @@ RSpec.describe Sso::Session, :type => :model do
     it { expect(Sso::Session.master).to eq [session] }
   end
 
+  describe "token based scopes" do
+
+    let(:user) { Fabricate(:user) }
+    let(:access_token) { Fabricate('Doorkeeper::AccessToken',
+                                   resource_owner_id: user.id) }
+    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+                                   application_id: nil,
+                                   resource_owner_id: user.id,
+                                   redirect_uri: 'http://localhost:3002/oauth/callback'
+                                  ) }
+
+    let(:session) {  Fabricate('Sso::Session', owner: user) }
+    let!(:client) {  Fabricate('Sso::Client', session: session,
+                                  access_token_id: access_token.id,
+                                  access_grant_id: access_grant.id) }
+
+    describe "::with_token_id" do
+      it { expect(Sso::Session.with_token_id(access_token.id).first).to eq session }
+    end
+
+    describe "::with_grant_id" do
+      it { expect(Sso::Session.with_grant_id(access_grant.id).first).to eq session }
+    end
+
+    describe "::by_access_token" do
+      it { expect(Sso::Session.by_access_token(access_token.token).first).to eq session }
+    end
+  end
+
+
   describe "::master_for" do
     let(:user) { Fabricate(:user) }
     let(:access_token) { Fabricate('Doorkeeper::AccessToken',
@@ -54,6 +83,11 @@ RSpec.describe Sso::Session, :type => :model do
         session = Sso::Session.generate_master(user, attributes)
         expect(session).to eq(Sso::Session.first)
       end
+
+      it "creates a new sso_client" do
+        session = Sso::Session.generate_master(user, attributes)
+        expect(session.clients.first).to eq Sso::Client.first
+      end
     end
 
     context "(failure)" do
@@ -63,30 +97,33 @@ RSpec.describe Sso::Session, :type => :model do
     end
   end
 
-  describe "::generate" do
-    let(:master_sso_session) { Sso::Session.generate_master(user, attributes) }
-    let(:user) { Fabricate(:user) }
-    let(:attributes) { { ip: "10.1.1.1", agent: "Safari" } }
-    let(:access_token) { Fabricate("Doorkeeper::AccessToken", resource_owner_id: user.id) }
-    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
-                                   application_id: nil,
-                                   resource_owner_id: user.id,
-                                   redirect_uri: 'http://localhost:3002/oauth/callback'
-                                  ) }
-    let(:session) { Sso::Session.generate(user, access_token, attributes) }
-    before do
-      # Notice: We assume our warden/doorkeeper is ok and a master with access grant/token is generated
-      master_sso_session.access_token_id = access_token.id
-      master_sso_session.access_grant_id = access_grant.id
-      master_sso_session.save
-    end
-
-    describe "creates a new session" do
-      it { expect(session.access_token_id).to eq access_token.id }
-      it { expect(session.application_id).to eq access_token.application.id }
-      it { expect(session.group_id).to eq master_sso_session.group_id }
-    end
-  end
+  # describe "::generate" do
+  #   let(:master_sso_session) { Fabricate('Sso::Session') }
+  #   let(:user) { Fabricate(:user) }
+  #   let(:attributes) { { ip: "10.1.1.1", agent: "Safari" } }
+  #   let(:access_token) { Fabricate("Doorkeeper::AccessToken", resource_owner_id: user.id) }
+  #   let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+  #                                  application_id: nil,
+  #                                  resource_owner_id: user.id,
+  #                                  redirect_uri: 'http://localhost:3002/oauth/callback'
+  #                                 ) }
+
+  #   let(:session) { Sso::Session.generate(user, access_token, attributes) }
+
+  #   before do
+  #     master_sso_session.clients.create(access_token: access_token, access_grant: access_grant )
+  #     # Notice: We assume our warden/doorkeeper is ok and a master with access grant/token is generated
+  #     master_sso_session.access_token_id = access_token.id
+  #     master_sso_session.access_grant_id = access_grant.id
+  #     master_sso_session.save
+  #   end
+
+  #   describe "creates a new session" do
+  #     it { expect(session.access_token_id).to eq access_token.id }
+  #     it { expect(session.application_id).to eq access_token.application.id }
+  #     it { expect(session.group_id).to eq master_sso_session.group_id }
+  #   end
+  # end
 
   describe "::logout" do
     let!(:sso_session) { Fabricate('Sso::Session') }
@@ -100,51 +137,51 @@ RSpec.describe Sso::Session, :type => :model do
     end
   end
 
-  describe "::update_master_with_grant" do
-    let(:user) { Fabricate(:user) }
-    let(:attributes) { { ip: "10.1.1.1", agent: "Safari" } }
-    let(:access_token) { Fabricate("Doorkeeper::AccessToken", resource_owner_id: user.id) }
-    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
-                                   application_id: nil,
-                                   resource_owner_id: user.id,
-                                   redirect_uri: 'http://localhost:3002/oauth/callback'
-                                  ) }
-    let!(:master_sso_session) { Sso::Session.generate_master(user, attributes) }
-
-    context "successful" do
-      it "updates master_sso_session.access_grant_id" do
-        expect{ Sso::Session.update_master_with_grant(master_sso_session.id, access_grant) }.to change{ master_sso_session.reload.access_grant_id }.from(nil).to(access_grant.id)
-      end
-    end
-  end
-
-  describe "::update_master_with_access_token" do
-    let(:user) { Fabricate(:user) }
-    let(:attributes) { { ip: "10.1.1.1", agent: "Safari" } }
-    let(:access_token) { Fabricate("Doorkeeper::AccessToken", resource_owner_id: user.id) }
-    let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
-                                   application_id: nil,
-                                   resource_owner_id: user.id,
-                                   redirect_uri: 'http://localhost:3002/oauth/callback'
-                                  ) }
-    let!(:master) { Sso::Session.generate_master(user, attributes) }
-
-    before do
-      # Notice: We assume our warden/doorkeeper is ok and a master with grant is generated
-      master.access_grant_id = access_grant.id
-      master.save
-    end
-
-    context "oauth_token not available" do
-      it "returns false" do
-        expect( Sso::Session.update_master_with_access_token(access_token.token, 123)).to be_falsey
-      end
-    end
-
-    it "updates master.access_token_it" do
-      expect{ Sso::Session.update_master_with_access_token(access_grant.token, access_token.token) }.to change{ master.reload.access_token_id }.from(nil).to(access_token.id)
-    end
-  end
+  # describe "::update_master_with_grant" do
+  #   let(:user) { Fabricate(:user) }
+  #   let(:attributes) { { ip: "10.1.1.1", agent: "Safari" } }
+  #   let(:access_token) { Fabricate("Doorkeeper::AccessToken", resource_owner_id: user.id) }
+  #   let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+  #                                  application_id: nil,
+  #                                  resource_owner_id: user.id,
+  #                                  redirect_uri: 'http://localhost:3002/oauth/callback'
+  #                                 ) }
+  #   let!(:master_sso_session) { Sso::Session.generate_master(user, attributes) }
+
+  #   context "successful" do
+  #     it "updates master_sso_session.access_grant_id" do
+  #       expect{ Sso::Session.update_master_with_grant(master_sso_session.id, access_grant) }.to change{ master_sso_session.reload.access_grant_id }.from(nil).to(access_grant.id)
+  #     end
+  #   end
+  # end
+
+  # describe "::update_master_with_access_token" do
+  #   let(:user) { Fabricate(:user) }
+  #   let(:attributes) { { ip: "10.1.1.1", agent: "Safari" } }
+  #   let(:access_token) { Fabricate("Doorkeeper::AccessToken", resource_owner_id: user.id) }
+  #   let(:access_grant) { Fabricate('Doorkeeper::AccessGrant',
+  #                                  application_id: nil,
+  #                                  resource_owner_id: user.id,
+  #                                  redirect_uri: 'http://localhost:3002/oauth/callback'
+  #                                 ) }
+  #   let!(:master) { Sso::Session.generate_master(user, attributes) }
+
+  #   before do
+  #     # Notice: We assume our warden/doorkeeper is ok and a master with grant is generated
+  #     master.access_grant_id = access_grant.id
+  #     master.save
+  #   end
+
+  #   context "oauth_token not available" do
+  #     it "returns false" do
+  #       expect( Sso::Session.update_master_with_access_token(access_token.token, 123)).to be_falsey
+  #     end
+  #   end
+
+  #   it "updates master.access_token_it" do
+  #     expect{ Sso::Session.update_master_with_access_token(access_grant.token, access_token.token) }.to change{ master.reload.access_token_id }.from(nil).to(access_token.id)
+  #   end
+  # end
 
 end
 

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@
 #
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
+require 'ffaker'
 require 'webmock/rspec'
 
 RSpec.configure do |config|

data/spec/support/api_schema_matcher.rb

@@ -0,0 +1,7 @@
+RSpec::Matchers.define :match_response_schema do |schema|
+  match do |response|
+    schema_directory = "#{Dir.pwd}/spec/api/schemas"
+    schema_path = "#{schema_directory}/#{schema}.json"
+    JSON::Validator.validate!(schema_path, response.body, strict: true)
+  end
+end

data/spec/test_app/Rakefile

@@ -1,2 +1,7 @@
 # Add your own tasks in files placed in lib/tasks ending in .rake,
 # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+require 'combustion'
+
+Combustion.path = 'spec/test_app'
+Combustion.initialize! :all
+Combustion::Application.load_tasks