lockbox_middleware 1.2.1 → 1.2.2

data/spec/controllers/application_controller_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe ApplicationController do
-
-  context "an instantiated controller" do
-
-    context "rendering jsonp" do
-      it "should pass the json straight through with no options" do
-        subject.stubs(:params).returns({})
-        subject.expects(:render).with({:text => 'foo'}).returns(true)
-        subject.render_jsonp('foo')
-      end
-
-      it "should return jsonp with variable assignment" do
-        subject.stubs(:params).returns({:variable => 'var'})
-        subject.expects(:render).with({:text => 'var var = foo;'}).returns(true)
-        subject.render_jsonp('foo')
-      end
-
-      it "should return jsonp with callback" do
-        subject.stubs(:params).returns({ :callback => 'callback'})
-        subject.expects(:render).with({:text => 'callback(foo);'}).returns(true)
-        subject.render_jsonp('foo')
-      end
-
-      it "should return jsonp with variable assignment and callback" do
-        subject.stubs(:params).returns({:variable => 'var', :callback => 'callback'})
-        subject.expects(:render).with({:text => "var var = foo;\ncallback(var);"}).returns(true)
-        subject.render_jsonp('foo')
-      end
-    end
-  end
-
-
-  
-end

data/spec/controllers/authentication_controller_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe AuthenticationController do
-  integrate_views
-  
-  context "with an existing partner" do
-    subject { Factory(:partner) }
-    
-    it "should return 200 for successful authentication" do
-      get :show, :id => subject.api_key
-      response.should be_success
-    end
-    
-    it "should return the API key in a header" do
-      get :show, :id => subject.api_key
-      response.headers['X-LockBox-API-Key'].should == subject.api_key
-    end
-    
-    it "should return 401 for unsuccessful authentication" do
-      get :show, :id => 'potato'
-      response.should_not be_success
-      response.status.should =~ /401/
-    end
-    
-    context "using HMAC authentication" do
-      subject { Factory(:partner) }
-      
-      before do
-        subject.stubs(:api_key).returns('daad465deb7718a5d0db99345be41e3a1ea0de6d')
-         Partner.stubs(:find_by_slug).returns(subject)
-         Partner.stubs(:find_by_api_key).returns(subject)
-         Time.stubs(:now).returns(Time.parse("2010-05-10 16:30:00 EDT"))
-         {'X-Referer-Method' => 'GET', 'X-Referer-Date' => [Time.now.httpdate], 'X-Referer-Authorization' => ['AuthHMAC cherry tree cutters:GurpT6GfwItXF3Co4Ut1a3I+3iI='], 'Referer' => 'http://example.org/api/some_controller/some_action'}.each_pair do |e,value|
-           request.env[e] = value
-        end
-      end
-      
-      it "should return 200 with valid HMAC credentials" do
-        get :show, :id => 'hmac'
-        response.should be_success
-      end
-    
-      it "should return 401 with invalid HMAC credentials" do
-        request.env['X-Referer-Authorization'] = ['AuthHMAC foo:bar']
-        get :show, :id => 'hmac'
-        response.should_not be_success
-        response.status.should =~ /401/
-      end
-    end
-    
-    it "should increment current_request_count for this partner after successful auth" do
-      count = subject.current_request_count
-      get :show, :id => subject.api_key
-      subject.current_request_count.should == count+1
-    end
-    
-    it "should return 420 once max_requests has been reached" do
-      # 420 is the code the Twitter rate limiting API uses
-      subject.requests_remaining.times do
-        subject.increment_request_count
-      end
-      get :show, :id => subject.api_key
-      response.should_not be_success
-      response.status.should =~ /420/
-    end
-    
-    it "should include an error message in the body when rate limited" do
-      subject.requests_remaining.times do
-        subject.increment_request_count
-      end
-      get :show, :id => subject.api_key
-      response.body.should =~ /Too many requests/
-    end
-    
-    it "should return Cache-Control header after successful auth" do
-      get :show, :id => subject.api_key
-      expected_cc_header = ['public', 'no-cache']
-      response.headers['Cache-Control'].split(/,\s*/).sort.should eql(expected_cc_header.sort)
-    end
-    
-    it "should return Twitter-style rate limit headers after successful auth" do
-      # these headers are documented here: http://apiwiki.twitter.com/Rate-limiting
-      get :show, :id => subject.api_key
-      expected_rl_headers = {
-        'X-RateLimit-Limit' => subject.max_requests,
-        'X-RateLimit-Remaining' => subject.requests_remaining,
-        'X-RateLimit-Reset' => subject.max_requests_reset_time,
-      }
-      rl_headers_received = Hash.new
-      expected_rl_headers.keys.map { |header|
-        rl_headers_received[header] = @response.headers[header].to_i
-      }
-      rl_headers_received.should eql(expected_rl_headers)
-    end
-
-  end
-
-  context "with a partner that has no max requests" do
-    subject { Factory(:partner, :max_requests => nil) }
-
-    it "should allow access" do
-      get :show, :id => subject.api_key
-      response.should be_success
-    end
-    
-    it "should not return rate limit headers after successful auth" do
-      get :show, :id => subject.api_key
-      response.headers.each_key do |header|
-        header.should_not =~ /^X-RateLimit-/
-      end
-    end
-    
-    it "should return Cache-Control header after successful auth" do
-      get :show, :id => subject.api_key
-      expected_cc_header = ['public', "max-age=#{subject.max_response_cache_time}", 'must-revalidate']
-      response.headers['Cache-Control'].split(/,\s*/).sort.should eql(expected_cc_header.sort)
-    end
-    
-  end
-end

data/spec/controllers/confirmation_controller_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe ConfirmationController do
-
-  context "Update" do
-    let(:partner) { Factory.build(:partner, :confirmed => false) }
-    let(:perishable_token) { "1234" }
-    
-    before do
-      partner.stubs(:save).returns(true)
-      Partner.stubs(:find_by_perishable_token!).returns(partner)
-      PartnerSession.stubs(:create)
-    end
-    
-    it "should redirect to /" do
-      get :update, :perishable_token => perishable_token
-      response.should redirect_to(root_path)
-    end
-    
-    it "should confirm the partner" do
-      partner.expects :save
-      get :update, :perishable_token => perishable_token
-      partner.should be_confirmed
-    end
-    
-    it "should find by the perishable token" do
-      Partner.expects(:find_by_perishable_token!).with(perishable_token).returns(partner)
-      get :update, :perishable_token => perishable_token
-    end
-    
-    it "should log the partner in" do
-      PartnerSession.expects(:create).with(partner)
-      get :update, :perishable_token => perishable_token
-    end
-  end
-end

data/spec/controllers/fetch_password_controller_spec.rb

@@ -1,155 +0,0 @@
-require 'spec_helper'
-
-describe FetchPasswordController do
-  include HelperMethods
-  
-  context "Index" do
-    let(:partner) { Partner.new }
-    
-    before do
-      Partner.stubs(:new).returns(partner)
-    end
-    
-    it "should respond with successful status" do
-      get :index
-      should respond_with :success
-    end
-    
-    it "should create a new instance of Partner" do
-      Partner.expects(:new)
-      get :index
-    end
-  end
-  
-  context "Show" do
-    let(:partner) { Factory.build(:partner) }
-    let(:partner_session) { PartnerSession.new }
-    let(:perishable_token) { "1234" }
-    
-    before do
-      Partner.stubs(:find_by_perishable_token!).returns(partner)
-    end
-    
-    context "Authenticates" do
-      before do
-        partner_session.stubs(:save).returns(true)
-        PartnerSession.stubs(:new).returns(partner_session)
-        get :show, :id => perishable_token
-      end
-      
-      it { should respond_with :success }
-    end
-    
-    context "Does not authenticate" do
-      before do
-        partner_session.stubs(:save).returns(false)
-        PartnerSession.stubs(:new).returns(partner_session)
-        get :show, :id => perishable_token
-      end
-      
-      its(:response) { should redirect_to fetch_password_index_path }
-    end
-  end
-  
-  context "Create" do
-    context "Valid" do
-      let(:partner) { Factory.build(:partner) }
-      
-      before do
-        Partner.stubs(:find_by_email).returns(partner)
-        PartnerMailer.stubs(:deliver_fetch_password)
-      end
-      
-      it "should redirect to /" do
-        post :create, :partner => { :email => partner.email }
-        response.should redirect_to root_path
-      end
-      
-      it "should find a partner by the email" do
-        Partner.expects(:find_by_email).with(partner.email)
-        post :create, :partner => { :email => partner.email }
-      end
-      
-      it "should deliver an email to the partner" do
-        PartnerMailer.expects(:deliver_fetch_password).with(partner)
-        post :create, :partner => { :email => partner.email }
-      end
-    end
-  
-    context "Invalid" do
-      let(:partner) { Partner.new(:email => "bademail@test.com") }
-      
-      before do
-        Partner.stubs(:find_by_email)
-        PartnerMailer.stubs(:deliver_fetch_password)
-      end
-      
-      it "should render in the index template" do
-        post :create, :partner => { :email => partner.email }
-        response.should render_template(:index)
-      end
-      
-      it "should assign a new instance of Partner to partner" do
-        post :create, :partner => { :email => partner.email }
-        assigns(:partner).should be_new_record
-      end
-      
-      it "should try to find a partner by the email" do
-        Partner.expects(:find_by_email).with(partner.email)
-        post :create, :partner => { :email => partner.email }
-      end
-      
-      it "should not deliver an email" do
-        PartnerMailer.expects(:deliver_fetch_password).never
-        post :create, :partner => { :email => partner.email }
-      end
-    end
-  end
-
-  context "Update" do
-    before do
-      stubbed_session_for(:partner)
-    end
-    
-    context "Valid" do
-      let(:password) { "goodpassword" }
-      let(:partner) { @partner }
-      
-      before do
-        partner.stubs(:save).returns(true)
-        FetchPasswordController.any_instance.stubs(:current_partner).returns(partner)
-      end
-      
-      it "should redirect to /" do
-        put :update, :partner => { :password => password, :password_confirmation => password }
-        response.should redirect_to root_path
-      end
-      
-      it "should attempt to save the record " do
-        partner.expects(:save)
-        put :update, :partner => { :password => password, :password_confirmation => password }
-      end
-    end
-    
-    context "Invalid" do
-      let(:password) { "badpassword" }
-      let(:partner) { @partner }
-      
-      before do
-        partner.stubs(:save).returns(false)
-        FetchPasswordController.any_instance.stubs(:current_partner).returns(partner)
-      end
-      
-      it "should render the show template" do
-        put :update, :partner => { :password => password }
-        response.should render_template :show
-      end
-      
-      it "should attempt to save the record " do
-        partner.expects(:save)
-        put :update, :partner => { :password => password }
-      end
-    end
-  end
-
-end

data/spec/controllers/home_controller_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe HomeController do
-
-  context "Show" do
-    subject do
-      get :show
-      response
-    end
-    
-    it { should be_success }
-    it { should render_template(:show) }
-  end
-
-end

data/spec/controllers/partner_sessions_controller_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe PartnerSessionsController do
-  include HelperMethods
-
-  context "Show" do
-    subject do
-      get :new
-      response
-    end
-    
-    it { should be_success }
-  end
-  
-  context "Create" do
-    let(:partner) { Factory(:partner) }
-
-    context "Valid" do
-      subject do
-        post :create, :partner_session => { :email => partner.email, 
-                                         :password => partner.password }
-        response.stubs(:response).returns(response)
-        response
-      end
-      
-      it { should redirect_to partners_path }
-      it { should set_the_flash.to "You have been signed in" }
-    end
-    
-    context "Does not exist" do
-      subject do
-        post :create, :partner_session => { :email => "x_#{partner.email}",
-                                         :password => partner.password }
-        response.stubs(:response).returns(response)
-        response
-      end
-      
-      it { should render_template :new }
-      it { should set_the_flash.to "Email doesn't exist or bad Pasword" }
-    end
-
-    context "Bad Password" do
-      subject do
-        post :create, :partner_session => { :email => partner.email, 
-                                         :password => "x_#{partner.password}" }
-        response.stubs(:response).returns(response)
-        response
-      end
-      
-      it { should render_template :new }
-      it { should set_the_flash.to "Email doesn't exist or bad Pasword" }
-    end
-
-  end
-  
-  context "Destroy" do
-    let(:current_partner_session) { mock("partner_session") }
-
-    before do
-      activate_authlogic
-      partner = Factory(:partner)
-      current_partner_session.stubs(:record => partner)
-      current_partner_session.stubs(:destroy => true)
-      PartnerSession.stubs(:find => current_partner_session)
-      session_for(partner)
-    end
-    
-    it "should set the flash" do
-      delete :destroy
-      should set_the_flash.to "You have been logged out"
-    end
-    
-    it "should redirect to /" do
-      delete :destroy
-      response.should redirect_to root_path
-    end
-    
-    it "should destory the session" do
-      current_partner_session.expects(:destroy)
-      delete :destroy
-    end
-  end
-
-end

data/spec/controllers/partners_controller_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-describe PartnersController do
-  include HelperMethods
-  
-  context "Index" do
-    before do
-      stubbed_session_for(:partner)
-      get :index
-    end
-    
-    it { should redirect_to partner_path(@partner.api_key) }
-
-  end
-
-  context "Create" do
-    before do
-      @partner = Factory(:partner)
-      @partner.stubs(:id).returns(1)
-      PartnerMailer.stubs(:deliver_confirmation)
-    end
-    
-    context "Valid" do
-      before do
-        @partner.stubs(:save).returns(true)
-        Partner.stubs(:new).returns(@partner)
-        post :create, :partner => Factory.attributes_for(:partner)
-      end
-      
-      it { should redirect_to partner_path(@partner.api_key) }
-      
-      it "should deliver the confirmation mail" do
-        assert_received(PartnerMailer, :deliver_confirmation) { |expect| expect.with(@partner) }
-      end
-    end
-    
-    context "Invalid" do
-      before do
-        @partner.stubs(:save).returns(false)
-        Partner.stubs(:new).returns(@partner)
-        post :create, :partner => { }
-      end
-    
-      it { should render_template :new }
-      
-      it "should not deliver the confirmation mail" do
-        assert_not_received(PartnerMailer, :deliver_confirmation)
-      end
-    end
-    
-  end
-
-  context "New" do
-    before do
-      get :new
-    end
-    
-    it { should respond_with :success }
-    it { should assign_to :partner }
-  end
-  
-  context "Show" do
-    before do
-      stubbed_session_for(:partner)
-      get :show,  :id => @partner.api_key
-    end
-    
-    it { should respond_with :success }
-    it { should assign_to :partner }
-  end
-
-  context "API Show" do
-    before do
-      stubbed_session_for(:partner)
-    end
-    context "json" do
-      before do
-        get :show,  :id => @partner.api_key, :format => 'json'
-      end
-
-      it { should respond_with :success }
-      it { should assign_to :partner }
-    end
-
-    context "jsonp" do
-      before do
-        get :show,  :id => @partner.api_key, :format => 'jsonp', :variable => 'foo', :callback => 'bar'
-      end
-
-      it { should respond_with :success }
-      it { should assign_to :partner }
-    end
-
-  end
-  
-  context "Edit" do
-    before do
-      stubbed_session_for(:partner)
-      get :edit, :id => @partner.api_key      
-    end
-    
-    it { should respond_with :success }
-    it { should assign_to :partner }
-  end
-  
-  context "Update" do
-    context "Valid" do
-      let(:partner) { Factory(:partner) }
-      
-      before do
-        partner.stubs(:save).returns(true)
-        stubbed_session_for(partner)
-        put :update, :partner => { }, :id => partner.api_key
-      end
-      
-      it { should redirect_to partner_path(partner.api_key) }
-    end
-    
-    context "Invalid" do
-      let(:partner) { Factory(:partner) }
-      
-      before do
-        partner.stubs(:save).returns(false)
-        stubbed_session_for(partner)
-        Partner.stubs(:find_by_api_key).returns(partner)
-        put :update, :partner => { }, :id => partner.api_key 
-      end
-      
-      it { should render_template :edit }
-    end
-  end
-end

data/spec/factories/partners.rb

@@ -1,14 +0,0 @@
-Factory.define :partner do |p|
-  p.name                  { "George Washington"}
-  p.organization          { "Cherry Tree Cutters"}
-  p.email                 { Factory.next(:email) }
-  p.phone_number          { "1112223333"}
-  p.max_requests          { 100 }
-  p.password              { "password" }
-  p.password_confirmation { "password" }
-  p.confirmed             { true }
-end
-
-Factory.sequence(:email) do |n|
-  "george_#{n}@ctc.com"
-end

data/spec/models/partner_mailer_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe PartnerMailer do
-
-  context "Confirmation Email" do
-    let(:partner) { Factory.build(:partner) }
-    
-    subject do
-      partner.stubs(:perishable_token).returns("1234")
-      PartnerMailer.create_confirmation(partner)
-    end
-    
-    it "should deliver to the partner email" do
-      subject.to.first.should == partner.email
-    end
-    
-    it "should be sent from out account" do
-      subject.from.first.should == "test@foo.org"
-    end
-    
-    its(:subject) { should == "Partner Account Confirmation" }
-    
-    its(:body) { should =~ /#{partner.perishable_token}/ }
-  end
-
-  context "Fetch Password Email" do
-    let(:partner) { Factory.build(:partner) }
-    
-    subject do
-      partner.stubs(:perishable_token).returns("1234")
-      PartnerMailer.create_fetch_password(partner)
-    end
-
-    it "should deliver to the partner email" do
-      subject.to.first.should == partner.email
-    end
-
-    it "should be sent from out account" do
-      subject.from.first.should == "test@foo.org"
-    end
-
-    its(:subject) { should == "Fetch Password" }
-
-    its(:body) { should =~ /#{partner.perishable_token}/ }
-  end
-
-end