spree_api 2.4.0.rc2 → 2.4.0.rc3

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::StockItemsController do
+  describe Api::StockItemsController, :type => :controller do
     render_views
 
     let!(:stock_location) { create(:stock_location_with_items) }
@@ -16,12 +16,12 @@ module Spree
     context "as a normal user" do
       it "cannot list stock items for a stock location" do
         api_get :index, stock_location_id: stock_location.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "cannot see a stock item" do
         api_get :show, stock_location_id: stock_location.to_param, id: stock_item.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "cannot create a stock item" do
@@ -35,17 +35,17 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "cannot update a stock item" do
         api_put :update, stock_location_id: stock_location.to_param, stock_item_id: stock_item.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "cannot destroy a stock item" do
         api_delete :destroy, stock_location_id: stock_location.to_param, stock_item_id: stock_item.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
@@ -54,33 +54,33 @@ module Spree
 
       it 'cannot list of stock items' do
         api_get :index, stock_location_id: stock_location.to_param
-        json_response['stock_items'].first.should have_attributes(attributes)
-        json_response['stock_items'].first['variant']['sku'].should include 'SKU'
+        expect(json_response['stock_items'].first).to have_attributes(attributes)
+        expect(json_response['stock_items'].first['variant']['sku']).to include 'SKU'
       end
 
       it 'requires a stock_location_id to be passed as a parameter' do
         api_get :index
-        json_response['error'].should =~ /stock_location_id parameter must be provided/
-        response.status.should == 422
+        expect(json_response['error']).to match(/stock_location_id parameter must be provided/)
+        expect(response.status).to eq(422)
       end
 
       it 'can control the page size through a parameter' do
         api_get :index, stock_location_id: stock_location.to_param, per_page: 1
-        json_response['count'].should == 1
-        json_response['current_page'].should == 1
+        expect(json_response['count']).to eq(1)
+        expect(json_response['current_page']).to eq(1)
       end
 
       it 'can query the results through a paramter' do
         stock_item.update_column(:count_on_hand, 30)
         api_get :index, stock_location_id: stock_location.to_param, q: { count_on_hand_eq: '30' }
-        json_response['count'].should == 1
-        json_response['stock_items'].first['count_on_hand'].should eq 30
+        expect(json_response['count']).to eq(1)
+        expect(json_response['stock_items'].first['count_on_hand']).to eq 30
       end
 
       it 'gets a stock item' do
         api_get :show, stock_location_id: stock_location.to_param, id: stock_item.to_param
-        json_response.should have_attributes(attributes)
-        json_response['count_on_hand'].should eq stock_item.count_on_hand
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response['count_on_hand']).to eq stock_item.count_on_hand
       end
 
       it 'can create a new stock item' do
@@ -97,12 +97,12 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
       end
 
       it 'can update a stock item to add new inventory' do
-        stock_item.count_on_hand.should == 10
+        expect(stock_item.count_on_hand).to eq(10)
         params = {
           id: stock_item.to_param,
           stock_item: {
@@ -111,12 +111,12 @@ module Spree
         }
 
         api_put :update, params
-        response.status.should == 200
-        json_response['count_on_hand'].should eq 50
+        expect(response.status).to eq(200)
+        expect(json_response['count_on_hand']).to eq 50
       end
 
       it 'can set a stock item to modify the current inventory' do
-        stock_item.count_on_hand.should == 10
+        expect(stock_item.count_on_hand).to eq(10)
 
         params = {
           id: stock_item.to_param,
@@ -127,14 +127,14 @@ module Spree
         }
 
         api_put :update, params
-        response.status.should == 200
-        json_response['count_on_hand'].should eq 40
+        expect(response.status).to eq(200)
+        expect(json_response['count_on_hand']).to eq 40
       end
 
       it 'can delete a stock item' do
         api_delete :destroy, id: stock_item.to_param
-        response.status.should == 204
-        lambda { Spree::StockItem.find(stock_item.id) }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { Spree::StockItem.find(stock_item.id) }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::StockLocationsController do
+  describe Api::StockLocationsController, :type => :controller do
     render_views
 
     let!(:stock_location) { create(:stock_location) }
@@ -14,12 +14,12 @@ module Spree
     context "as a user" do
       it "cannot see stock locations" do
         api_get :index
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
 
       it "cannot see a single stock location" do
         api_get :show, :id => stock_location.id
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "cannot create a new stock location" do
@@ -31,17 +31,17 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
 
       it "cannot update a stock location" do
         api_put :update, :stock_location => { :name => "South Pole" }, :id => stock_location.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "cannot delete a stock location" do
         api_put :destroy, :id => stock_location.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
@@ -51,30 +51,30 @@ module Spree
 
       it "gets list of stock locations" do
         api_get :index
-        json_response['stock_locations'].first.should have_attributes(attributes)
-        json_response['stock_locations'].first['country'].should_not be_nil
-        json_response['stock_locations'].first['state'].should_not be_nil
+        expect(json_response['stock_locations'].first).to have_attributes(attributes)
+        expect(json_response['stock_locations'].first['country']).not_to be_nil
+        expect(json_response['stock_locations'].first['state']).not_to be_nil
       end
 
       it 'can control the page size through a parameter' do
         create(:stock_location)
         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(:stock_location, name: 'South America')
         api_get :index, q: { name_cont: 'south' }
-        json_response['count'].should == 1
-        json_response['stock_locations'].first['name'].should eq expected_result.name
+        expect(json_response['count']).to eq(1)
+        expect(json_response['stock_locations'].first['name']).to eq expected_result.name
       end
 
       it "gets a stock location" do
         api_get :show, id: stock_location.to_param
-        json_response.should have_attributes(attributes)
-        json_response['name'].should eq stock_location.name
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response['name']).to eq stock_location.name
       end
 
       it "can create a new stock location" do
@@ -86,8 +86,8 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
       end
 
       it "can update a stock location" do
@@ -99,14 +99,14 @@ module Spree
         }
 
         api_put :update, params
-        response.status.should == 200
-        json_response['name'].should eq 'South Pole'
+        expect(response.status).to eq(200)
+        expect(json_response['name']).to eq 'South Pole'
       end
 
       it "can delete a stock location" do
         api_delete :destroy, id: stock_location.to_param
-        response.status.should == 204
-        lambda { stock_location.reload }.should raise_error(ActiveRecord::RecordNotFound)
+        expect(response.status).to eq(204)
+        expect { stock_location.reload }.to raise_error(ActiveRecord::RecordNotFound)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::StockMovementsController do
+  describe Api::StockMovementsController, :type => :controller do
     render_views
 
     let!(:stock_location) { create(:stock_location_with_items) }
@@ -16,12 +16,12 @@ module Spree
     context 'as a user' do
       it 'cannot see a list of stock movements' do
         api_get :index, stock_location_id: stock_location.to_param
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it 'cannot see a stock movement' do
         api_get :show, stock_location_id: stock_location.to_param, id: stock_movement.id
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it 'cannot create a stock movement' do
@@ -33,7 +33,7 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
@@ -42,34 +42,34 @@ module Spree
 
       it 'gets list of stock movements' do
         api_get :index, stock_location_id: stock_location.to_param
-        json_response['stock_movements'].first.should have_attributes(attributes)
-        json_response['stock_movements'].first['stock_item']['count_on_hand'].should eq 11
+        expect(json_response['stock_movements'].first).to have_attributes(attributes)
+        expect(json_response['stock_movements'].first['stock_item']['count_on_hand']).to eq 11
       end
 
       it 'requires a stock_location_id to be passed as a parameter' do
         api_get :index
-        json_response['error'].should =~ /stock_location_id parameter must be provided/
-        response.status.should == 422
+        expect(json_response['error']).to match(/stock_location_id parameter must be provided/)
+        expect(response.status).to eq(422)
       end
 
       it 'can control the page size through a parameter' do
         create(:stock_movement, stock_item: stock_item)
         api_get :index, stock_location_id: stock_location.to_param, 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(:stock_movement, :received, quantity: 10, stock_item: stock_item)
         api_get :index, stock_location_id: stock_location.to_param, q: { quantity_eq: '10' }
-        json_response['count'].should == 1
+        expect(json_response['count']).to eq(1)
       end
 
       it 'gets a stock movement' do
         api_get :show, stock_location_id: stock_location.to_param, id: stock_movement.to_param
-        json_response.should have_attributes(attributes)
-        json_response['stock_item_id'].should eq stock_movement.stock_item_id
+        expect(json_response).to have_attributes(attributes)
+        expect(json_response['stock_item_id']).to eq stock_movement.stock_item_id
       end
 
       it 'can create a new stock movement' do
@@ -81,8 +81,8 @@ module Spree
         }
 
         api_post :create, params
-        response.status.should == 201
-        json_response.should have_attributes(attributes)
+        expect(response.status).to eq(201)
+        expect(json_response).to have_attributes(attributes)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::TaxonomiesController do
+  describe Api::TaxonomiesController, :type => :controller do
     render_views
 
     let(:taxonomy) { create(:taxonomy) }
@@ -20,57 +20,57 @@ module Spree
       it "gets all taxonomies" do
         api_get :index
 
-        json_response["taxonomies"].first['name'].should eq taxonomy.name
-        json_response["taxonomies"].first['root']['taxons'].count.should eq 1
+        expect(json_response["taxonomies"].first['name']).to eq taxonomy.name
+        expect(json_response["taxonomies"].first['root']['taxons'].count).to eq 1
       end
 
       it 'can control the page size through a parameter' do
         create(:taxonomy)
         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(:taxonomy, :name => 'Style')
         api_get :index, :q => { :name_cont => 'style' }
-        json_response['count'].should == 1
-        json_response['taxonomies'].first['name'].should eq expected_result.name
+        expect(json_response['count']).to eq(1)
+        expect(json_response['taxonomies'].first['name']).to eq expected_result.name
       end
 
       it "gets a single taxonomy" do
         api_get :show, :id => taxonomy.id
 
-        json_response['name'].should eq taxonomy.name
+        expect(json_response['name']).to eq taxonomy.name
 
         children = json_response['root']['taxons']
-        children.count.should eq 1
-        children.first['name'].should eq taxon.name
-        children.first.key?('taxons').should be false
+        expect(children.count).to eq 1
+        expect(children.first['name']).to eq taxon.name
+        expect(children.first.key?('taxons')).to be false
       end
 
       it "gets a single taxonomy with set=nested" do
         api_get :show, :id => taxonomy.id, :set => 'nested'
 
-        json_response['name'].should eq taxonomy.name
+        expect(json_response['name']).to eq taxonomy.name
 
         children = json_response['root']['taxons']
-        children.first.key?('taxons').should be true
+        expect(children.first.key?('taxons')).to be true
       end
 
       it "gets the jstree-friendly version of a taxonomy" do
         api_get :jstree, :id => taxonomy.id
-        json_response["data"].should eq(taxonomy.root.name)
-        json_response["attr"].should eq({ "id" => taxonomy.root.id, "name" => taxonomy.root.name})
-        json_response["state"].should eq("closed")
+        expect(json_response["data"]).to eq(taxonomy.root.name)
+        expect(json_response["attr"]).to eq({ "id" => taxonomy.root.id, "name" => taxonomy.root.name})
+        expect(json_response["state"]).to eq("closed")
       end
 
       it "can learn how to create a new taxonomy" do
         api_get :new
-        json_response["attributes"].should == attributes.map(&:to_s)
+        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
         required_attributes = json_response["required_attributes"]
-        required_attributes.should include("name")
+        expect(required_attributes).to include("name")
       end
 
       it "cannot create a new taxonomy if not an admin" do
@@ -94,20 +94,20 @@ module Spree
 
       it "can create" do
         api_post :create, :taxonomy => { :name => "Colors"}
-        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 "cannot create a new taxonomy with invalid attributes" do
         api_post :create, :taxonomy => {}
-        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
 
       it "can destroy" do
         api_delete :destroy, :id => taxonomy.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Api::TaxonsController do
+  describe Api::TaxonsController, :type => :controller do
     render_views
 
     let(:taxonomy) { create(:taxonomy) }
@@ -20,19 +20,19 @@ module Spree
       it "gets all taxons for a taxonomy" do
         api_get :index, :taxonomy_id => taxonomy.id
 
-        json_response['taxons'].first['name'].should eq taxon.name
+        expect(json_response['taxons'].first['name']).to eq taxon.name
         children = json_response['taxons'].first['taxons']
-        children.count.should eq 1
-        children.first['name'].should eq taxon2.name
-        children.first['taxons'].count.should eq 1
+        expect(children.count).to eq 1
+        expect(children.first['name']).to eq taxon2.name
+        expect(children.first['taxons'].count).to eq 1
       end
 
       # Regression test for #4112
       it "does not include children when asked not to" do
         api_get :index, :taxonomy_id => taxonomy.id, :without_children => 1
 
-        json_response['taxons'].first['name'].should eq(taxon.name)
-        json_response['taxons'].first['taxons'].should be_nil
+        expect(json_response['taxons'].first['name']).to eq(taxon.name)
+        expect(json_response['taxons'].first['taxons']).to be_nil
       end
 
       it "paginates through taxons" do
@@ -57,8 +57,8 @@ module Spree
             let(:name) { "Ruby" }
 
             it "returns an array including the matching taxon" do
-              json_response['taxons'].count.should == 1
-              json_response['taxons'].first['name'].should eq "Ruby"
+              expect(json_response['taxons'].count).to eq(1)
+              expect(json_response['taxons'].first['name']).to eq "Ruby"
             end
           end
 
@@ -66,8 +66,8 @@ module Spree
             let(:name) { "Imaginary" }
 
             it 'returns an empty array of taxons' do
-              json_response.keys.should include('taxons')
-              json_response['taxons'].count.should == 0
+              expect(json_response.keys).to include('taxons')
+              expect(json_response['taxons'].count).to eq(0)
             end
           end
         end
@@ -76,11 +76,11 @@ module Spree
           it "gets all taxons" do
             api_get :index
 
-            json_response['taxons'].first['name'].should eq taxonomy.root.name
+            expect(json_response['taxons'].first['name']).to eq taxonomy.root.name
             children = json_response['taxons'].first['taxons']
-            children.count.should eq 1
-            children.first['name'].should eq taxon.name
-            children.first['taxons'].count.should eq 1
+            expect(children.count).to eq 1
+            expect(children.first['name']).to eq taxon.name
+            expect(children.first['taxons'].count).to eq 1
           end
         end
       end
@@ -88,23 +88,23 @@ module Spree
       it "gets a single taxon" do
         api_get :show, :id => taxon.id, :taxonomy_id => taxonomy.id
 
-        json_response['name'].should eq taxon.name
-        json_response['taxons'].count.should eq 1
+        expect(json_response['name']).to eq taxon.name
+        expect(json_response['taxons'].count).to eq 1
       end
 
       it "gets all taxons in JSTree form" do
         api_get :jstree, :taxonomy_id => taxonomy.id, :id => taxon.id
         response = json_response.first
-        response["data"].should eq(taxon2.name)
-        response["attr"].should eq({ "name" => taxon2.name, "id" => taxon2.id})
-        response["state"].should eq("closed")
+        expect(response["data"]).to eq(taxon2.name)
+        expect(response["attr"]).to eq({ "name" => taxon2.name, "id" => taxon2.id})
+        expect(response["state"]).to eq("closed")
       end
 
       it "can learn how to create a new taxon" do
         api_get :new, :taxonomy_id => taxonomy.id
-        json_response["attributes"].should == attributes.map(&:to_s)
+        expect(json_response["attributes"]).to eq(attributes.map(&:to_s))
         required_attributes = json_response["required_attributes"]
-        required_attributes.should include("name")
+        expect(required_attributes).to include("name")
       end
 
       it "cannot create a new taxon if not an admin" do
@@ -128,48 +128,48 @@ module Spree
 
       it "can create" do
         api_post :create, :taxonomy_id => taxonomy.id, :taxon => { :name => "Colors" }
-        json_response.should have_attributes(attributes)
-        response.status.should == 201
+        expect(json_response).to have_attributes(attributes)
+        expect(response.status).to eq(201)
 
-        taxonomy.reload.root.children.count.should eq 2
+        expect(taxonomy.reload.root.children.count).to eq 2
         taxon = Spree::Taxon.where(:name => 'Colors').first
 
-        taxon.parent_id.should eq taxonomy.root.id
-        taxon.taxonomy_id.should eq taxonomy.id
+        expect(taxon.parent_id).to eq taxonomy.root.id
+        expect(taxon.taxonomy_id).to eq taxonomy.id
       end
 
       it "can update the position in the list" do
         taxonomy.root.children << taxon2
         api_put :update, :taxonomy_id => taxonomy.id, :id => taxon.id, :taxon => {:parent_id => taxon.parent_id, :child_index => 2 }
-        response.status.should == 200
-        taxonomy.reload.root.children[0].should eql taxon2
-        taxonomy.reload.root.children[1].should eql taxon
+        expect(response.status).to eq(200)
+        expect(taxonomy.reload.root.children[0]).to eql taxon2
+        expect(taxonomy.reload.root.children[1]).to eql taxon
       end
 
       it "cannot create a new taxon with invalid attributes" do
         api_post :create, :taxonomy_id => taxonomy.id, :taxon => {}
-        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"]
 
-        taxonomy.reload.root.children.count.should eq 1
+        expect(taxonomy.reload.root.children.count).to eq 1
       end
 
       it "cannot create a new taxon with invalid taxonomy_id" do
         api_post :create, :taxonomy_id => 1000, :taxon => { :name => "Colors" }
-        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"]
-        errors["taxonomy_id"].should_not be_nil
-        errors["taxonomy_id"].first.should eq "Invalid taxonomy id."
+        expect(errors["taxonomy_id"]).not_to be_nil
+        expect(errors["taxonomy_id"].first).to eq "Invalid taxonomy id."
 
-        taxonomy.reload.root.children.count.should eq 1
+        expect(taxonomy.reload.root.children.count).to eq 1
       end
 
       it "can destroy" do
         api_delete :destroy, :taxonomy_id => taxonomy.id, :id => taxon.id
-        response.status.should == 204
+        expect(response.status).to eq(204)
       end
     end