spree_api 3.1.5 → 3.1.6

data/spec/controllers/spree/api/v1/states_controller_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe Api::V1::StatesController, :type => :controller do
-    render_views
-
-    let!(:state) { create(:state, :name => "Victoria") }
-    let(:attributes) { [:id, :name, :abbr, :country_id] }
-
-    before do
-      stub_authentication!
-    end
-
-    it "gets all states" do
-      api_get :index
-      expect(json_response["states"].first).to have_attributes(attributes)
-      expect(json_response['states'].first['name']).to eq(state.name)
-    end
-
-    it "gets all the states for a particular country" do
-      api_get :index, :country_id => state.country.id
-      expect(json_response["states"].first).to have_attributes(attributes)
-      expect(json_response['states'].first['name']).to eq(state.name)
-    end
-
-    context "pagination" do
-      let(:scope) { double('scope') }
-
-      before do
-        expect(scope).to receive_messages(last: state)
-        expect(State).to receive_messages(accessible_by: scope)
-        expect(scope).to receive_messages(order: scope)
-        allow(scope).to receive_message_chain(:ransack, :result, :includes).and_return(scope)
-      end
-
-      it "does not paginate states results when asked not to do so" do
-        expect(scope).not_to receive(:page)
-        expect(scope).not_to receive(:per)
-        api_get :index
-      end
-
-      it "paginates when page parameter is passed through" do
-        expect(scope).to receive(:page).with(1).and_return(scope)
-        expect(scope).to receive(:per).with(nil).and_return(scope)
-        api_get :index, :page => 1
-      end
-
-      it "paginates when per_page parameter is passed through" do
-        expect(scope).to receive(:page).with(nil).and_return(scope)
-        expect(scope).to receive(:per).with(25).and_return(scope)
-        api_get :index, :per_page => 25
-      end
-    end
-
-
-    context "with two states" do
-      before { create(:state, :name => "New South Wales") }
-
-      it "gets all states for a country" do
-        country = create(:country, :states_required => true)
-        state.country = country
-        state.save
-
-        api_get :index, :country_id => country.id
-        expect(json_response["states"].first).to have_attributes(attributes)
-        expect(json_response["states"].count).to eq(1)
-        json_response["states_required"] = true
-      end
-
-      it "can view all states" do
-        api_get :index
-        expect(json_response["states"].first).to have_attributes(attributes)
-      end
-
-      it 'can query the results through a paramter' do
-        api_get :index, :q => { :name_cont => 'Vic' }
-        expect(json_response['states'].first['name']).to eq("Victoria")
-      end
-    end
-
-    it "can view a state" do
-      api_get :show, :id => state.id
-      expect(json_response).to have_attributes(attributes)
-    end
-  end
-end

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

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe Api::V1::StockItemsController, :type => :controller do
-    render_views
-
-    let!(:stock_location) { create(:stock_location_with_items) }
-    let!(:stock_item) { stock_location.stock_items.order(:id).first }
-    let!(:attributes) { [:id, :count_on_hand, :backorderable,
-                         :stock_location_id, :variant_id] }
-
-    before do
-      stub_authentication!
-    end
-
-    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
-        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
-        expect(response.status).to eq(404)
-      end
-
-      it "cannot create a stock item" do
-        variant = create(:variant)
-        params = {
-          stock_location_id: stock_location.to_param,
-          stock_item: {
-            variant_id: variant.id,
-            count_on_hand: '20'
-          }
-        }
-
-        api_post :create, params
-        expect(response.status).to eq(404)
-      end
-
-      it "cannot update a stock item" do
-        api_put :update, stock_location_id: stock_location.to_param,
-          id: stock_item.to_param
-        expect(response.status).to eq(404)
-      end
-
-      it "cannot destroy a stock item" do
-        api_delete :destroy, stock_location_id: stock_location.to_param,
-          id: stock_item.to_param
-        expect(response.status).to eq(404)
-      end
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      it 'cannot list of stock items' do
-        api_get :index, stock_location_id: stock_location.to_param
-        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
-        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
-        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' }
-        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
-        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
-        variant = create(:variant)
-        # Creating a variant also creates stock items.
-        # We don't want any to exist (as they would conflict with what we're about to create)
-        StockItem.delete_all
-        params = {
-          stock_location_id: stock_location.to_param,
-          stock_item: {
-            variant_id: variant.id,
-            count_on_hand: '20'
-          }
-        }
-
-        api_post :create, params
-        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
-        expect(stock_item.count_on_hand).to eq(10)
-        params = {
-          id: stock_item.to_param,
-          stock_item: {
-            count_on_hand: 40,
-          }
-        }
-
-        api_put :update, params
-        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
-        expect(stock_item.count_on_hand).to eq(10)
-
-        params = {
-          id: stock_item.to_param,
-          stock_item: {
-            count_on_hand: 40,
-            force: true,
-          }
-        }
-
-        api_put :update, params
-        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
-        expect(response.status).to eq(204)
-        expect { Spree::StockItem.find(stock_item.id) }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe Api::V1::StockLocationsController, :type => :controller do
-    render_views
-
-    let!(:stock_location) { create(:stock_location) }
-    let!(:attributes) { [:id, :name, :address1, :address2, :city, :state_id, :state_name, :country_id, :zipcode, :phone, :active] }
-
-    before do
-      stub_authentication!
-    end
-
-    context "as a user" do
-      it "cannot see stock locations" do
-        api_get :index
-        expect(response.status).to eq(401)
-      end
-
-      it "cannot see a single stock location" do
-        api_get :show, :id => stock_location.id
-        expect(response.status).to eq(404)
-      end
-
-      it "cannot create a new stock location" do
-        params = {
-          stock_location: {
-            name: "North Pole",
-            active: true
-          }
-        }
-
-        api_post :create, params
-        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
-        expect(response.status).to eq(404)
-      end
-
-      it "cannot delete a stock location" do
-        api_put :destroy, :id => stock_location.to_param
-        expect(response.status).to eq(404)
-      end
-    end
-
-    
-    context "as an admin" do
-      sign_in_as_admin!
-
-      it "gets list of stock locations" do
-        api_get :index
-        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
-        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' }
-        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
-        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
-        params = {
-          stock_location: {
-            name: "North Pole",
-            active: true
-          }
-        }
-
-        api_post :create, params
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-      end
-
-      it "can update a stock location" do
-        params = {
-          id: stock_location.to_param,
-          stock_location: {
-            name: "South Pole"
-          }
-        }
-
-        api_put :update, params
-        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
-        expect(response.status).to eq(204)
-        expect { stock_location.reload }.to raise_error(ActiveRecord::RecordNotFound)
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe Api::V1::StockMovementsController, :type => :controller do
-    render_views
-
-    let!(:stock_location) { create(:stock_location_with_items) }
-    let!(:stock_item) { stock_location.stock_items.order(:id).first }
-    let!(:stock_movement) { create(:stock_movement, stock_item: stock_item) }
-    let!(:attributes) { [:id, :quantity, :stock_item_id] }
-
-    before do
-      stub_authentication!
-    end
-
-    context 'as a user' do
-      it 'cannot see a list of stock movements' do
-        api_get :index, stock_location_id: stock_location.to_param
-        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
-        expect(response.status).to eq(404)
-      end
-
-      it 'cannot create a stock movement' do
-        params = {
-          stock_location_id: stock_location.to_param,
-          stock_movement: {
-            stock_item_id: stock_item.to_param
-          }
-        }
-
-        api_post :create, params
-        expect(response.status).to eq(404)
-      end
-    end
-
-    context 'as an admin' do
-      sign_in_as_admin!
-
-      it 'gets list of stock movements' do
-        api_get :index, stock_location_id: stock_location.to_param
-        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 '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
-        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' }
-        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
-        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
-        params = {
-          stock_location_id: stock_location.to_param,
-          stock_movement: {
-            stock_item_id: stock_item.to_param
-          }
-        }
-
-        api_post :create, params
-        expect(response.status).to eq(201)
-        expect(json_response).to have_attributes(attributes)
-      end
-    end
-  end
-end
-

data/spec/controllers/spree/api/v1/stores_controller_spec.rb

@@ -1,133 +0,0 @@
-require "spec_helper"
-
-module Spree
-  describe Api::V1::StoresController, type: :controller do
-    render_views
-
-    let!(:store) do
-      create(:store, name: "My Spree Store", url: "spreestore.example.com")
-    end
-
-    before do
-      stub_authentication!
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      let!(:non_default_store) do
-        create(:store,
-          name: "Extra Store",
-          url: "spreestore-5.example.com",
-          default: false
-        )
-      end
-
-      it "I can list the available stores" do
-        api_get :index
-        expect(json_response["stores"]).to eq([
-          {
-            "id" => store.id,
-            "name" => "My Spree Store",
-            "url" => "spreestore.example.com",
-            "meta_description" => nil,
-            "meta_keywords" => nil,
-            "seo_title" => nil,
-            "mail_from_address" => "spree@example.org",
-            "default_currency" => nil,
-            "code" => store.code,
-            "default" => true
-          },
-          {
-            "id" => non_default_store.id,
-            "name" => "Extra Store",
-            "url" => "spreestore-5.example.com",
-            "meta_description" => nil,
-            "meta_keywords" => nil,
-            "seo_title" => nil,
-            "mail_from_address" => "spree@example.org",
-            "default_currency" => nil,
-            "code" => non_default_store.code,
-            "default" => false
-          }
-        ])
-      end
-
-      it "I can get the store details" do
-        api_get :show, id: store.id
-        expect(json_response).to eq(
-          "id" => store.id,
-          "name" => "My Spree Store",
-          "url" => "spreestore.example.com",
-          "meta_description" => nil,
-          "meta_keywords" => nil,
-          "seo_title" => nil,
-          "mail_from_address" => "spree@example.org",
-          "default_currency" => nil,
-          "code" => store.code,
-          "default" => true
-        )
-      end
-
-      it "I can create a new store" do
-        store_hash = {
-          code: "spree123",
-          name: "Hack0rz",
-          url: "spree123.example.com",
-          mail_from_address: "me@example.com"
-        }
-        api_post :create, store: store_hash
-        expect(response.status).to eq(201)
-      end
-
-      it "I can update an existing store" do
-        store_hash = {
-          url: "spree123.example.com",
-          mail_from_address: "me@example.com"
-        }
-        api_put :update, id: store.id, store: store_hash
-        expect(response.status).to eq(200)
-        expect(store.reload.url).to eql "spree123.example.com"
-        expect(store.reload.mail_from_address).to eql "me@example.com"
-      end
-
-      context "deleting a store" do
-        it "will fail if it's the default Store" do
-          api_delete :destroy, id: store.id
-          expect(response.status).to eq(422)
-          expect(json_response["errors"]["base"]).to eql(
-          ["Cannot destroy the default Store."]
-          )
-        end
-
-        it "will destroy the store" do
-          api_delete :destroy, id: non_default_store.id
-          expect(response.status).to eq(204)
-        end
-      end
-    end
-
-    context "as an user" do
-
-      it "I cannot list all the stores" do
-        api_get :index
-        expect(response.status).to eq(401)
-      end
-
-      it "I cannot get the store details" do
-        api_get :show, id: store.id
-        expect(response.status).to eq(401)
-      end
-
-      it "I cannot create a new store" do
-        api_post :create, store: {}
-        expect(response.status).to eq(401)
-      end
-
-      it "I cannot update an existing store" do
-        api_put :update, id: store.id, store: {}
-        expect(response.status).to eq(401)
-      end
-    end
-  end
-end