cassette 1.0.18 → 1.1.0

data/spec/cassette/authentication_spec.rb

@@ -1,27 +1,39 @@
 # encoding: utf-8
-
-require 'spec_helper'
-
 describe Cassette::Authentication do
   let(:cache) { instance_double(Cassette::Authentication::Cache) }
   let(:http)  { class_double(Cassette) }
 
-  subject do
+  subject(:authentication) do
     Cassette::Authentication.new(cache: cache, http_client: http)
   end
 
   describe '#ticket_user' do
+    subject(:ticket_user) { authentication.ticket_user(ticket) }
+
+    let(:ticket) { 'ticket' }
+    let(:cached_value) { 'cached_value' }
+    let(:service) { 'test-api.example.org' }
+
     context 'when cached' do
-      it 'returns the cached value when cached' do
-        cached = double('cached')
+      before do
+        allow(cache).to receive(:fetch_authentication)
+          .and_return(cached_value)
+      end
+
+      it { is_expected.to eql(cached_value) }
+      it 'calls Cache#fetch_authentication with ticket and service' do
+        expect(cache).to receive(:fetch_authentication)
+          .with(ticket, service)
+
+        ticket_user
+      end
 
-        expect(cache).to receive(:fetch_authentication) do |ticket, &block|
-          expect(ticket).to eql('ticket')
+      it 'passes a block to Cache#fetch_authentication' do
+        expect(cache).to receive(:fetch_authentication) do |*, &block|
           expect(block).to be_present
-          cached
         end
 
-        expect(subject.ticket_user('ticket')).to eql(cached)
+        ticket_user
       end
     end
 
@@ -44,7 +56,7 @@ describe Cassette::Authentication do
         end
 
         it 'returns nil' do
-          expect(subject.ticket_user('ticket')).to be_nil
+          expect(ticket_user).to be_nil
         end
       end
 
@@ -55,7 +67,7 @@ describe Cassette::Authentication do
         end
 
         it 'returns an User' do
-          expect(subject.ticket_user('ticket')).to be_instance_of(Cassette::Authentication::User)
+          expect(ticket_user).to be_instance_of(Cassette::Authentication::User)
         end
       end
     end

data/spec/cassette/cache_spec.rb

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-require 'spec_helper'
-
 describe Cassette::Cache do
   subject do
     c = Class.new

data/spec/cassette/client/cache_spec.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'spec_helper'
+
 
 describe Cassette::Client::Cache do
   pending

data/spec/cassette/client_spec.rb

@@ -0,0 +1,319 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Cassette::Client do
+  let(:http) { class_double(Cassette) }
+  let(:cache) { instance_double(Cassette::Client::Cache) }
+  let(:options) do
+    {
+      http_client: http,
+      cache: cache,
+    }
+  end
+
+  let(:client) do
+    Cassette::Client.new(options)
+  end
+
+  describe '#health_check' do
+    subject { client.health_check }
+
+    it 'raises any Error' do
+      expect(client).to receive(:st_for).with(anything).and_raise('Failure')
+
+      expect { subject }.to raise_error('Failure')
+    end
+
+    it 'tries to generate a ST' do
+      expect(client).to receive(:st_for).with(an_instance_of(String)).and_return('ST-Something')
+
+      expect(subject).to eq 'ST-Something'
+    end
+  end
+
+  describe '#tgt' do
+    subject { client.tgt('user', 'pass', force) }
+
+    context 'http client interactions' do
+      let(:force) { true }
+      let(:response) { Faraday::Response.new }
+
+      before do
+        allow(cache).to receive(:fetch_tgt).and_yield
+        allow(http).to receive(:post) { response }
+      end
+
+      it 'extracts the tgt from the Location header' do
+        tgt = 'TGT-something'
+        allow(response).to receive(:headers).and_return('Location' => "/tickets/#{tgt}")
+
+        expect(subject).to eq tgt
+      end
+
+      it 'posts the username and password' do
+        subject
+        expect(http).to have_received(:post).with(anything, username: 'user', password: 'pass')
+      end
+
+      it 'posts to a /v1/tickets uri' do
+        subject
+        expect(http).to have_received(:post).with(%r{/v1/tickets\z}, instance_of(Hash))
+      end
+    end
+
+    context 'when tgt is not cached' do
+      let(:tgt) { 'TGT-Something-example' }
+      let(:force) { false }
+
+      before do
+        allow(cache).to receive(:fetch_tgt) do |opts, &_block|
+          expect(opts[:force]).to eq false
+          tgt
+        end
+
+        allow(http).to receive(:post)
+      end
+
+      it { is_expected.to eq tgt }
+    end
+
+    context 'with a cached tgt' do
+      let(:tgt) { 'TGT-Something-example' }
+
+      before do
+        allow(cache).to receive(:fetch_tgt).with(hash_including(force: force))
+          .and_return(tgt)
+
+        allow(http).to receive(:post)
+      end
+
+      shared_context 'force control' do
+        it { is_expected.to eq tgt }
+
+        it 'forwards force to the cache' do
+          subject
+          expect(cache).to have_received(:fetch_tgt).with(hash_including(force: force))
+        end
+      end
+
+      context 'and no force' do
+        let(:force) { false }
+
+        include_context 'force control'
+      end
+
+      context 'and using the force' do
+        let(:force) { true }
+
+        include_context 'force control'
+      end
+    end
+  end
+
+  describe '#st' do
+    subject { client.st(tgt_param, service, force) }
+    let(:service) { 'example.org' }
+    let(:tgt) { 'TGT-Example' }
+    let(:st) { 'ST-Something-example' }
+    let(:tgt_param) { tgt }
+
+    shared_context 'http client interactions' do
+      let(:force) { true }
+      let(:response) { Faraday::Response.new }
+
+      before do
+        allow(cache).to receive(:fetch_st).and_yield
+        allow(http).to receive(:post) { response }
+      end
+
+      it 'extracts the tgt from the Location header' do
+        allow(response).to receive(:body) { st }
+
+        expect(subject).to eq st
+      end
+
+      it 'posts the service' do
+        subject
+
+        expect(http).to have_received(:post).with(anything, service: service)
+      end
+
+      it 'posts to the tgt uri' do
+        subject
+
+        expect(http).to have_received(:post).with(%r{/#{tgt}\z}, instance_of(Hash))
+      end
+    end
+
+    context 'when tgt is a string' do
+      let(:tgt_param) { tgt }
+
+      it_behaves_like 'http client interactions'
+    end
+
+    context 'when tgt is a callable' do
+      let(:tgt_param) { ->{ tgt } }
+
+      it_behaves_like 'http client interactions'
+    end
+
+    context 'cache control' do
+      before do
+        allow(cache).to receive(:fetch_st).with(service, hash_including(force: force))
+          .and_return(st)
+      end
+
+      shared_context 'controlling the force' do
+        it { is_expected.to eq st }
+
+        it 'forwards force to the cache' do
+          subject
+
+          expect(cache).to have_received(:fetch_st).with(service, hash_including(force: force))
+        end
+      end
+
+      context 'not using the force' do
+        let(:force) { false }
+
+        include_context 'controlling the force'
+      end
+
+      context 'using the force' do
+        let(:force) { true }
+
+        include_context 'controlling the force'
+      end
+    end
+  end
+
+  describe '#st_for' do
+    subject { client.st_for(service) }
+    let(:service) { 'example.org' }
+    let(:cached_tgt) { 'TGT-Something' }
+    let(:tgt)  { 'TGT-Something-NEW' }
+    let(:st) { 'ST-For-Something' }
+
+    context 'when tgt and st are not cached' do
+      before do
+        allow(cache).to receive(:fetch_tgt).with(hash_including(force: false)).and_yield
+        allow(cache).to receive(:fetch_st).with(service, hash_including(force: false)).and_yield
+
+        allow(http).to receive(:post)
+          .with(%r{/v1/tickets\z}, username: Cassette.config.username, password: Cassette.config.password)
+          .and_return(tgt_response)
+
+        allow(http).to receive(:post).with(%r{/v1/tickets/#{tgt}\z}, service: service)
+          .and_return(st_response)
+      end
+
+      let(:st_response) { Faraday::Response.new(body: st) }
+      let(:tgt_response) { Faraday::Response.new(response_headers: {'Location' => "/v1/tickets/#{tgt}"}) }
+
+      it 'returns the generated st' do
+        expect(subject).to eq st
+      end
+
+      it 'generates an ST' do
+        subject
+
+        expect(http).to have_received(:post).with(%r{/v1/tickets/#{tgt}\z}, service: service)
+      end
+
+      it 'generates a TGT' do
+        subject
+
+        expect(http).to have_received(:post)
+          .with(%r{/v1/tickets\z}, username: Cassette.config.username, password: Cassette.config.password)
+      end
+    end
+
+    context 'when tgt is cached but st is not' do
+      before do
+        allow(cache).to receive(:fetch_tgt).with(hash_including(force: false)).and_return(tgt)
+        allow(cache).to receive(:fetch_st).with(service, hash_including(force: false)).and_yield
+
+        allow(http).to receive(:post).with(%r{/v1/tickets/#{tgt}\z}, service: service)
+          .and_return(st_response)
+      end
+
+      let(:st_response) { Faraday::Response.new(body: st) }
+
+      it 'returns the generated st' do
+        expect(subject).to eq st
+      end
+
+      it 'generates an ST' do
+        subject
+
+        expect(http).to have_received(:post).with(%r{/v1/tickets/#{tgt}\z}, service: service)
+      end
+    end
+
+    context 'when st is cached' do
+      before do
+        allow(cache).to receive(:fetch_st).with(service, hash_including(force: false)).and_return(st)
+      end
+
+      it 'returns the cached value' do
+        expect(subject).to eq st
+      end
+    end
+
+    context 'when tgt is expired' do
+      before do
+        allow(cache).to receive(:fetch_tgt).with(hash_including(force: false)).and_return(cached_tgt)
+        allow(cache).to receive(:fetch_tgt).with(hash_including(force: true)).and_yield
+        allow(cache).to receive(:fetch_st).and_yield
+
+        allow(http).to receive(:post).with(%r{/v1/tickets/#{cached_tgt}\z}, service: service)
+          .and_raise(Cassette::Errors::NotFound)
+
+        allow(http).to receive(:post)
+          .with(%r{/v1/tickets\z}, username: Cassette.config.username, password: Cassette.config.password)
+          .and_return(tgt_response)
+
+        allow(http).to receive(:post).with(%r{/v1/tickets/#{tgt}\z}, service: service)
+          .and_return(st_response)
+      end
+
+      let(:tgt_response) { Faraday::Response.new(response_headers: {'Location' => "/v1/tickets/#{tgt}"}) }
+      let(:st_response) { Faraday::Response.new(body: st) }
+
+      it 'calls #fetch_st twice' do
+        subject
+
+        expect(cache).to have_received(:fetch_st).twice
+      end
+
+      it 'calls #fetch_tgt without forcing' do
+        subject
+
+        expect(cache).to have_received(:fetch_tgt).with(force: false)
+      end
+
+      it 'calls #fetch_tgt forcing' do
+        subject
+
+        expect(cache).to have_received(:fetch_tgt).with(force: true)
+      end
+
+      it 'tries to generate a ST with the expired TGT' do
+        subject
+
+        expect(http).to have_received(:post).with(%r{/v1/tickets/#{cached_tgt}\z}, service: service)
+      end
+
+      it 'retries to generate a ST with the new TGT' do
+        subject
+
+        expect(http).to have_received(:post).with(%r{/v1/tickets/#{tgt}\z}, service: service)
+      end
+
+      it 'returns a brand new tgt' do
+        expect(subject).to eq st
+      end
+    end
+  end
+end

data/spec/cassette/errors_spec.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'spec_helper'
+
 
 describe Cassette::Errors do
   describe Cassette::Errors::Base do

data/spec/cassette/http/parsed_response_spec.rb

@@ -0,0 +1,27 @@
+describe Cassette::Http::ParsedResponse do
+  subject(:parsed_response) { described_class.new(xml_response) }
+
+  let(:xml_response) { fixture('cas/success.xml') }
+
+  let(:hash_response) do
+    {
+      "serviceResponse" => {
+        "authenticationSuccess" => {
+          "user"=> {
+            "__content__" => "test-user"
+          },
+          "attributes" => {
+            "authorities" => {
+              "__content__" => "[CUPOM, AUDITING,]"
+            },
+            "cn" => {
+              "__content__" => "Test System"
+            }
+          }
+        }
+      }
+    }
+  end
+
+  it { is_expected.to eq(hash_response) }
+end

data/spec/cassette/http/request_spec.rb

@@ -0,0 +1,41 @@
+describe Cassette::Http::Request do
+  subject(:request) { described_class }
+
+  describe '.post' do
+    subject(:post) { request.post(uri, payload) }
+
+    let(:uri) { 'http://example.org/' }
+    let(:payload) { { ping: :pong } }
+    let(:response) do
+      {
+        headers: { 'Content-Type' => 'application/json' },
+        body: { ok: :true }.to_json,
+        status: 200
+      }
+    end
+
+    before { stub_request(:post, uri).to_return(response) }
+
+    it 'performs a http post request with the proper params'do
+      post
+
+      expect(a_request(:post, uri).with(body: 'ping=pong')).to have_been_made
+    end
+
+    it do
+      is_expected.to have_attributes(
+        headers: { 'Content-Type' => 'application/json' },
+        body: '{"ok":"true"}',
+        status: 200
+      )
+    end
+
+    context 'when response has an error status code' do
+      let(:response) { { status: 500 } }
+
+      it 'raises an exception' do
+        expect { post }.to raise_error(Cassette::Errors::InternalServerError)
+      end
+    end
+  end
+end

data/spec/cassette/http/ticket_response_spec.rb

@@ -0,0 +1,41 @@
+describe Cassette::Http::TicketResponse do
+  subject(:ticket_response) { described_class.new(xml_response) }
+
+  let(:xml_response) { fixture('cas/success.xml') }
+
+  describe '#login' do
+    subject(:login) { ticket_response.login }
+
+    it { is_expected.to eq('test-user') }
+
+    context "when response isn't successful"  do
+      let(:xml_response) { fixture('cas/fail.xml') }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#name' do
+    subject(:name) { ticket_response.name }
+
+    it { is_expected.to eq('Test System') }
+
+    context "when response isn't successful"  do
+      let(:xml_response) { fixture('cas/fail.xml') }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe '#authorities' do
+    subject(:authorities) { ticket_response.authorities }
+
+    it { is_expected.to eq('[CUPOM, AUDITING,]') }
+
+    context "when response isn't successful"  do
+      let(:xml_response) { fixture('cas/fail.xml') }
+
+      it { is_expected.to be_nil }
+    end
+  end
+end

data/spec/cassette/rubycas/routing_constraint_spec.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Cassette::Rubycas::RoutingConstraint do
+  describe '#matches?' do
+    let(:request) do
+      OpenStruct.new(session: session)
+    end
+
+    let(:user) { instance_double(Cassette::Authentication::User) }
+    let(:constraint) { described_class.new(role, options) }
+
+    subject { constraint.matches?(request) }
+
+    before do
+      allow(constraint).to receive(:from_session).with(session).and_return(user)
+    end
+
+    let(:session) do
+      {
+        cas_user: 'test.user',
+        cas_extra_attributes: {
+          cn: 'test user',
+          email: 'test.user@example.org'
+        }
+      }
+    end
+
+    context 'with no options' do
+      let(:role) { :admin }
+      let(:options) { {} }
+      let(:has_role) { true }
+
+      before do
+        allow(user).to receive(:has_role?).with(role).and_return(has_role)
+      end
+
+      it 'checks the User role' do
+        subject
+        expect(user).to have_received(:has_role?).with(role)
+      end
+
+      context 'when user has the role' do
+        let(:has_role) { true }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context 'when user does not have the role' do
+        let(:has_role) { false }
+
+        it { is_expected.to eq(false) }
+      end
+    end
+
+    context 'when options[:raw] = true' do
+      let(:role) { 'API_ADMIN' }
+      let(:options) { { raw: true } }
+      let(:has_role) { true }
+
+      before do
+        allow(user).to receive(:has_raw_role?).with(role).and_return(has_role)
+      end
+
+      it 'checks the User role' do
+        subject
+        expect(user).to have_received(:has_raw_role?).with(role)
+      end
+
+      context 'when user has the role' do
+        let(:has_role) { true }
+
+        it { is_expected.to eq(true) }
+      end
+
+      context 'when user does not have the role' do
+        let(:has_role) { false }
+
+        it { is_expected.to eq(false) }
+      end
+    end
+  end
+end

data/spec/cassette_spec.rb

@@ -0,0 +1,36 @@
+
+
+describe Cassette do
+  def keeping_logger(&block)
+    original_logger = Cassette.logger
+    block.call
+    Cassette.logger = original_logger
+  end
+
+  describe '.logger' do
+    it 'returns a default instance' do
+      expect(Cassette.logger).not_to be_nil
+      expect(Cassette.logger.is_a?(Logger)).to eql(true)
+    end
+
+    it 'returns rails logger when Rails is available' do
+      keeping_logger do
+        Cassette.logger = nil
+        rails = double('Rails')
+        expect(rails).to receive(:logger).and_return(rails).at_least(:once)
+        stub_const('Rails', rails)
+        expect(Cassette.logger).to eql(rails)
+      end
+    end
+  end
+
+  describe '.logger=' do
+    let(:logger) { Logger.new(STDOUT) }
+    it 'defines the logger instance' do
+      keeping_logger do
+        Cassette.logger = logger
+        expect(Cassette.logger).to eq(logger)
+      end
+    end
+  end
+end

data/spec/integration/cas/client_spec.rb

@@ -1,7 +1,4 @@
 # encoding: utf-8
-
-require 'spec_helper'
-
 RSpec.describe 'Cassette::Client, Cassette::Authentication integration' do
   shared_examples_for 'a Cassette client and validator' do
     let(:config) { fail 'implement config!' }

data/spec/spec_helper.rb

@@ -2,6 +2,11 @@ require 'simplecov'
 require 'simplecov-rcov'
 require 'simplecov-gem-adapter'
 require 'yaml'
+require 'webmock/rspec'
+require 'rspec/its'
+require 'faker'
+
+Dir['spec/support/**/*.rb'].each { |f| load f }
 
 module Fixtures
   def fixture(name)

data/spec/support/controllers/controller_mock.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/hash/indifferent_access'
+
+def ControllerMock(*mods)
+  mods.inject(Class.new(ControllerMock)) do |c, mod|
+    c.send(:include, mod)
+  end
+end
+
+class ControllerMock
+  attr_accessor :params, :request, :current_user
+  def self.before_filter(*); end
+
+  def initialize(params = {}, headers = {})
+    self.params = params.with_indifferent_access
+    self.request = OpenStruct.new(headers: headers.with_indifferent_access)
+  end
+end