spree_api 2.4.0.rc2 → 2.4.0.rc3

data/spec/controllers/spree/api/unauthenticated_products_controller_spec.rb

@@ -2,7 +2,7 @@ require 'shared_examples/protect_product_actions'
 require 'spec_helper'
 
 module Spree
-  describe Spree::Api::ProductsController do
+  describe Spree::Api::ProductsController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -11,12 +11,12 @@ module Spree
     context "without authentication" do
       before { Spree::Api::Config[:requires_authentication] = false }
 
-      it "retreives a list of products" do
+      it "retrieves a list of products" do
         api_get :index
-        json_response["products"].first.should have_attributes(attributes)
-        json_response["count"].should == 1
-        json_response["current_page"].should == 1
-        json_response["pages"].should == 1
+        expect(json_response["products"].first).to have_attributes(attributes)
+        expect(json_response["count"]).to eq(1)
+        expect(json_response["current_page"]).to eq(1)
+        expect(json_response["pages"]).to eq(1)
       end
 
       it_behaves_like "modifying product actions are restricted"

data/spec/controllers/spree/api/users_controller_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::UsersController do
+  describe Api::UsersController, :type => :controller do
     render_views
 
     let(:user) { create(:user) }
@@ -12,13 +12,13 @@ module Spree
 
     context "as a normal user" do
       before do
-        controller.stub :try_spree_current_user => user
+        allow(controller).to receive_messages :try_spree_current_user => user
       end
 
       it "can get own details" do
         api_get :show, :id => user.id
 
-        json_response['email'].should eq user.email
+        expect(json_response['email']).to eq user.email
       end
 
       it "cannot get other users details" do
@@ -29,19 +29,19 @@ module Spree
 
       it "can learn how to create a new user" do
         api_get :new
-        json_response["attributes"].should == attributes.map(&:to_s)
+        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
       end
 
       it "can create a new user" do
         api_post :create, :user => { :email => 'new@example.com', :password => 'spree123', :password_confirmation => 'spree123' }
-        json_response['email'].should eq 'new@example.com'
+        expect(json_response['email']).to eq 'new@example.com'
       end
 
       # there's no validations on LegacyUser?
       xit "cannot create a new user with invalid attributes" do
         api_post :create, :user => {}
-        response.status.should == 422
-        json_response["error"].should == "Invalid resource. Please fix errors and try again."
+        expect(response.status).to eq(422)
+        expect(json_response["error"]).to eq("Invalid resource. Please fix errors and try again.")
         errors = json_response["errors"]
       end
 
@@ -82,7 +82,7 @@ module Spree
 
       it "can delete itself" do
         api_delete :destroy, :id => user.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
 
       it "cannot delete other user" do
@@ -94,9 +94,9 @@ module Spree
         2.times { create(:user) }
         api_get :index
 
-        Spree.user_class.count.should eq 3
-        json_response['count'].should eq 1
-        json_response['users'].size.should eq 1
+        expect(Spree.user_class.count).to eq 3
+        expect(json_response['count']).to eq 1
+        expect(json_response['users'].size).to eq 1
       end
     end
 
@@ -104,48 +104,48 @@ module Spree
       sign_in_as_admin!
 
       it "gets all users" do
-        Spree::LegacyUser.stub(:find_by).with(hash_including(:spree_api_key)) { current_api_user }
+        allow(Spree::LegacyUser).to receive(:find_by).with(hash_including(:spree_api_key)) { current_api_user }
 
         2.times { create(:user) }
 
         api_get :index
-        Spree.user_class.count.should eq 2
-        json_response['count'].should eq 2
-        json_response['users'].size.should eq 2
+        expect(Spree.user_class.count).to eq 2
+        expect(json_response['count']).to eq 2
+        expect(json_response['users'].size).to eq 2
       end
 
       it 'can control the page size through a parameter' do
         2.times { create(:user) }
         api_get :index, :per_page => 1
-        json_response['count'].should == 1
-        json_response['current_page'].should == 1
-        json_response['pages'].should == 2
+        expect(json_response['count']).to eq(1)
+        expect(json_response['current_page']).to eq(1)
+        expect(json_response['pages']).to eq(2)
       end
 
       it 'can query the results through a paramter' do
         expected_result = create(:user, :email => 'brian@spreecommerce.com')
         api_get :index, :q => { :email_cont => 'brian' }
-        json_response['count'].should == 1
-        json_response['users'].first['email'].should eq expected_result.email
+        expect(json_response['count']).to eq(1)
+        expect(json_response['users'].first['email']).to eq expected_result.email
       end
 
       it "can create" do
         api_post :create, :user => { :email => "new@example.com", :password => 'spree123', :password_confirmation => 'spree123' }
-        json_response.should have_attributes(attributes)
-        response.status.should == 201
+        expect(json_response).to have_attributes(attributes)
+        expect(response.status).to eq(201)
       end
 
       it "can destroy user without orders" do
         user.orders.destroy_all
         api_delete :destroy, :id => user.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
 
       it "cannot destroy user with orders" do
         create(:completed_order_with_totals, :user => user)
         api_delete :destroy, :id => user.id
-        json_response["exception"].should eq "Spree::Core::DestroyWithOrdersError"
-        response.status.should == 422
+        expect(json_response["exception"]).to eq "Spree::Core::DestroyWithOrdersError"
+        expect(response.status).to eq(422)
       end
 
     end

data/spec/controllers/spree/api/variants_controller_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::VariantsController do
+  describe Api::VariantsController, :type => :controller do
     render_views
 
     let!(:product) { create(:product) }
@@ -22,32 +22,32 @@ module Spree
     it "can see a paginated list of variants" do
       api_get :index
       first_variant = json_response["variants"].first
-      first_variant.should have_attributes(show_attributes)
-      first_variant["stock_items"].should be_present
-      json_response["count"].should == 1
-      json_response["current_page"].should == 1
-      json_response["pages"].should == 1
+      expect(first_variant).to have_attributes(show_attributes)
+      expect(first_variant["stock_items"]).to be_present
+      expect(json_response["count"]).to eq(1)
+      expect(json_response["current_page"]).to eq(1)
+      expect(json_response["pages"]).to eq(1)
     end
 
     it 'can control the page size through a parameter' do
       create(:variant)
       api_get :index, :per_page => 1
-      json_response['count'].should == 1
-      json_response['current_page'].should == 1
-      json_response['pages'].should == 3
+      expect(json_response['count']).to eq(1)
+      expect(json_response['current_page']).to eq(1)
+      expect(json_response['pages']).to eq(3)
     end
 
     it 'can query the results through a parameter' do
       expected_result = create(:variant, :sku => 'FOOBAR')
       api_get :index, :q => { :sku_cont => 'FOO' }
-      json_response['count'].should == 1
-      json_response['variants'].first['sku'].should eq expected_result.sku
+      expect(json_response['count']).to eq(1)
+      expect(json_response['variants'].first['sku']).to eq expected_result.sku
     end
 
     it "variants returned contain option values data" do
       api_get :index
       option_values = json_response["variants"].last["option_values"]
-      option_values.first.should have_attributes([:name,
+      expect(option_values.first).to have_attributes([:name,
                                                  :presentation,
                                                  :option_type_name,
                                                  :option_type_id])
@@ -58,8 +58,8 @@ module Spree
 
       api_get :index
 
-      json_response["variants"].last.should have_attributes([:images])
-      json_response['variants'].first['images'].first.should have_attributes([:attachment_file_name,
+      expect(json_response["variants"].last).to have_attributes([:images])
+      expect(json_response['variants'].first['images'].first).to have_attributes([:attachment_file_name,
                                                                                :attachment_width,
                                                                                :attachment_height,
                                                                                :attachment_content_type,
@@ -83,12 +83,12 @@ module Spree
 
       it "is not returned in the results" do
         api_get :index
-        json_response["variants"].count.should == 0
+        expect(json_response["variants"].count).to eq(0)
       end
 
       it "is not returned even when show_deleted is passed" do
         api_get :index, :show_deleted => true
-        json_response["variants"].count.should == 0
+        expect(json_response["variants"].count).to eq(0)
       end
     end
 
@@ -96,19 +96,19 @@ module Spree
       it "can select the next page of variants" do
         second_variant = create(:variant)
         api_get :index, :page => 2, :per_page => 1
-        json_response["variants"].first.should have_attributes(show_attributes)
-        json_response["total_count"].should == 3
-        json_response["current_page"].should == 2
-        json_response["pages"].should == 3
+        expect(json_response["variants"].first).to have_attributes(show_attributes)
+        expect(json_response["total_count"]).to eq(3)
+        expect(json_response["current_page"]).to eq(2)
+        expect(json_response["pages"]).to eq(3)
       end
     end
 
     it "can see a single variant" do
       api_get :show, :id => variant.to_param
-      json_response.should have_attributes(show_attributes)
-      json_response["stock_items"].should be_present
+      expect(json_response).to have_attributes(show_attributes)
+      expect(json_response["stock_items"]).to be_present
       option_values = json_response["option_values"]
-      option_values.first.should have_attributes([:name,
+      expect(option_values.first).to have_attributes([:name,
                                                  :presentation,
                                                  :option_type_name,
                                                  :option_type_id])
@@ -119,9 +119,9 @@ module Spree
 
       api_get :show, :id => variant.to_param
 
-      json_response.should have_attributes(show_attributes + [:images])
+      expect(json_response).to have_attributes(show_attributes + [:images])
       option_values = json_response["option_values"]
-      option_values.first.should have_attributes([:name,
+      expect(option_values.first).to have_attributes([:name,
                                                  :presentation,
                                                  :option_type_name,
                                                  :option_type_id])
@@ -129,8 +129,8 @@ module Spree
 
     it "can learn how to create a new variant" do
       api_get :new
-      json_response["attributes"].should == new_attributes.map(&:to_s)
-      json_response["required_attributes"].should be_empty
+      expect(json_response["attributes"]).to eq(new_attributes.map(&:to_s))
+      expect(json_response["required_attributes"]).to be_empty
     end
 
     it "cannot create a new variant if not an admin" do
@@ -146,7 +146,7 @@ module Spree
     it "cannot delete a variant" do
       api_delete :destroy, :id => variant.to_param
       assert_not_found!
-      lambda { variant.reload }.should_not raise_error
+      expect { variant.reload }.not_to raise_error
     end
 
     context "as an admin" do
@@ -161,28 +161,28 @@ module Spree
 
         it "are visible by admin" do
           api_get :index, :show_deleted => 1
-          json_response["variants"].count.should == 1
+          expect(json_response["variants"].count).to eq(1)
         end
       end
 
       it "can create a new variant" do
         api_post :create, :variant => { :sku => "12345" }
-        json_response.should have_attributes(new_attributes)
-        response.status.should == 201
-        json_response["sku"].should == "12345"
+        expect(json_response).to have_attributes(new_attributes)
+        expect(response.status).to eq(201)
+        expect(json_response["sku"]).to eq("12345")
 
-        variant.product.variants.count.should == 1
+        expect(variant.product.variants.count).to eq(1)
       end
 
       it "can update a variant" do
         api_put :update, :id => variant.to_param, :variant => { :sku => "12345" }
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "can delete a variant" do
         api_delete :destroy, :id => variant.to_param
-        response.status.should == 204
-        lambda { Spree::Variant.find(variant.id) }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { Spree::Variant.find(variant.id) }.to raise_error(ActiveRecord::RecordNotFound)
       end
 
       it 'variants returned contain cost price data' do

data/spec/controllers/spree/api/zones_controller_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::ZonesController do
+  describe Api::ZonesController, :type => :controller do
     render_views
 
     let!(:attributes) { [:id, :name, :zone_members] }
@@ -13,29 +13,29 @@ module Spree
 
     it "gets list of zones" do
       api_get :index
-      json_response['zones'].first.should have_attributes(attributes)
+      expect(json_response['zones'].first).to have_attributes(attributes)
     end
 
     it 'can control the page size through a parameter' do
       create(:zone)
       api_get :index, :per_page => 1
-      json_response['count'].should == 1
-      json_response['current_page'].should == 1
-      json_response['pages'].should == 2
+      expect(json_response['count']).to eq(1)
+      expect(json_response['current_page']).to eq(1)
+      expect(json_response['pages']).to eq(2)
     end
 
     it 'can query the results through a paramter' do
       expected_result = create(:zone, :name => 'South America')
       api_get :index, :q => { :name_cont => 'south' }
-      json_response['count'].should == 1
-      json_response['zones'].first['name'].should eq expected_result.name
+      expect(json_response['count']).to eq(1)
+      expect(json_response['zones'].first['name']).to eq expected_result.name
     end
 
     it "gets a zone" do
       api_get :show, :id => @zone.id
-      json_response.should have_attributes(attributes)
-      json_response['name'].should eq @zone.name
-      json_response['zone_members'].size.should eq @zone.zone_members.count
+      expect(json_response).to have_attributes(attributes)
+      expect(json_response['name']).to eq @zone.name
+      expect(json_response['zone_members'].size).to eq @zone.zone_members.count
     end
 
     context "specifying a rabl template to use" do
@@ -50,13 +50,13 @@ module Spree
       it "uses the specified template" do
         request.headers['X-Spree-Template'] = 'show'
         api_get :custom_show, :id => @zone.id
-        response.should render_template('spree/api/zones/show')
+        expect(response).to render_template('spree/api/zones/show')
       end
 
       it "falls back to the default template if the specified template does not exist" do
         request.headers['X-Spree-Template'] = 'invoice'
         api_get :show, :id => @zone.id
-        response.should render_template('spree/api/zones/show')
+        expect(response).to render_template('spree/api/zones/show')
       end
     end
 
@@ -77,9 +77,9 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
-        json_response["zone_members"].should_not be_empty
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response["zone_members"]).not_to be_empty
       end
 
       it "updates a zone" do
@@ -96,15 +96,15 @@ module Spree
         }
 
         api_put :update, params
-        response.status.should == 200
-        json_response['name'].should eq 'North Pole'
-        json_response['zone_members'].should_not be_blank
+        expect(response.status).to eq(200)
+        expect(json_response['name']).to eq 'North Pole'
+        expect(json_response['zone_members']).not_to be_blank
       end
 
       it "can delete a zone" do
         api_delete :destroy, :id => @zone.id
-        response.status.should == 204
-        lambda { @zone.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { @zone.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end

data/spec/models/spree/legacy_user_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 module Spree
-  describe LegacyUser do
+  describe LegacyUser, :type => :model do
     let(:user) { LegacyUser.new }
 
     it "can generate an API key" do
-      user.should_receive(:save!)
+      expect(user).to receive(:save!)
       user.generate_spree_api_key!
-      user.spree_api_key.should_not be_blank
+      expect(user.spree_api_key).not_to be_blank
     end
 
     it "can clear an API key" do
-      user.should_receive(:save!)
+      expect(user).to receive(:save!)
       user.clear_spree_api_key!
-      user.spree_api_key.should be_blank
+      expect(user.spree_api_key).to be_blank
     end
   end
 end