solidus_json_api 0.3.0

data/spec/controllers/spree/api/v2/base_controller_spec.rb

@@ -0,0 +1,46 @@
+describe Spree::Api::V2::BaseController do
+  controller do
+    skip_before_action :authenticate_user
+
+    def index
+      render_collection Spree::Order
+    end
+  end
+
+  describe '#filter_params' do
+    before do
+      allow(controller).to receive(:serializer_attributes) { Spree::OrderSerializer._attributes }
+    end
+
+    let!(:orders) do
+      [create(:order), create(:order), create(:order, frontend_viewable: false)]
+    end
+
+    it 'can filter by a serializer\'s attribute' do
+      first_order = orders.first
+      get :index, filter: { id: first_order.id }
+      order_ids = parse_json(response.body)['data'].map do |order|
+        order['id']
+      end
+      expect(order_ids).to match [first_order.id.to_s]
+    end
+
+    it 'can filter multiple attributes' do
+      first_order, second_order, _third_order = orders
+      get :index, filter: { id: [first_order.id, second_order.id] }
+      order_ids = parse_json(response.body)['data'].map do |order|
+        order['id'].to_i
+      end
+
+      expect(order_ids).to match [first_order.id, second_order.id]
+    end
+
+    it 'will allow filtering of non-serializer attributes' do
+      get :index, filter: { frontend_viewable: false }
+      order_ids = parse_json(response.body)['data'].map do |order|
+        order['id'].to_i
+      end
+      expect(order_ids).to match orders.map(&:id)
+    end
+  end
+end

data/spec/controllers/spree/api/v2/children_controller_spec.rb

@@ -0,0 +1,28 @@
+describe Spree::Api::V2::ChildrenController do
+  routes { Spree::Core::Engine.routes }
+
+  let(:taxon) { create :taxon }
+  let!(:child) { create :taxon, parent: taxon, taxonomy: taxon.taxonomy }
+
+  describe '#index' do
+    context 'by taxon' do
+      it 'can list all the children' do
+        get :index, taxon_id: taxon.id
+        taxon_ids = parse_json(response.body)['data'].map do |taxon|
+          taxon['id']
+        end
+        expect(taxon_ids).to include child.id.to_s
+      end
+    end
+  end
+
+  describe '#show' do
+    context 'by taxon' do
+      it 'will fetch the selected child' do
+        get :show, taxon_id: taxon.id, id: child.id
+        child_id = parse_json(response.body)['data']['id']
+        expect(child_id).to eql child.id.to_s
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/countries_controller_spec.rb

@@ -0,0 +1,25 @@
+describe Spree::Api::V2::CountriesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:country) { create :country }
+  let(:state) { create :state, country: country }
+
+  describe '#index' do
+    it 'will list all countries' do
+      get :index
+      expect(JSON.parse(response.body)['data'].length).to eql 1
+    end
+  end
+
+  describe '#show' do
+    it 'will list the selected country' do
+      get :show, id: country.id
+      expect(JSON.parse(response.body)['data']['id']).to eql country.id.to_s
+    end
+
+    it 'will the country via a state' do
+      get :show, state_id: state.id
+      expect(JSON.parse(response.body)['data']['id']).to eql country.id.to_s
+    end
+  end
+end

data/spec/controllers/spree/api/v2/images_controller_spec.rb

@@ -0,0 +1,91 @@
+describe Spree::Api::V2::ImagesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:image) { create :image }
+
+  let(:product) { create :product }
+  let(:new_product) { create :product }
+
+  let(:variant) { create :variant, images: [image] }
+  let(:new_variant) { create :variant, images: [create(:image)] }
+
+  describe '#index' do
+    it 'will list the images' do
+      get :index
+      image_ids = parse_json(response.body)['data'].map do |image|
+        image['id']
+      end
+      expect(image_ids).to include image.id.to_s
+    end
+
+    context 'by product id' do
+      it 'will list its images' do
+        product.images << image
+        get :index, product_id: product.id
+        image_ids = parse_json(response.body)['data'].map do |image|
+          image['id']
+        end
+        expect(image_ids).to include image.id.to_s
+      end
+
+      it 'will not list another products images' do
+        get :index, product_id: new_product.id
+        data = parse_json(response.body)['data']
+        expect(data).to be_empty
+      end
+    end
+
+    context 'by variant id' do
+      it 'will list its images' do
+        get :index, variant_id: variant.id
+        image_ids = parse_json(response.body)['data'].map do |image|
+          image['id']
+        end
+        expect(image_ids).to include image.id.to_s
+      end
+
+      it 'will not list another variants images' do
+        get :index, variant_id: new_variant.id
+        image_ids = parse_json(response.body)['data'].map do |image|
+          image['id']
+        end
+        expect(image_ids).to_not include image.id.to_s
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will show the image' do
+      get :show, id: image.id
+      image_id = parse_json(response.body)['data']['id']
+      expect(image_id).to eql image.id.to_s
+    end
+
+    context 'by product id' do
+      it 'will show its image' do
+        product.images << image
+        get :show, id: image.id, product_id: product.id
+        image_id = parse_json(response.body)['data']['id']
+        expect(image_id).to eql image.id.to_s
+      end
+
+      it 'will not show another products image' do
+        get :show, id: image.id, product_id: new_product.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by variant id' do
+      it 'will show its image' do
+        get :show, id: image.id, variant_id: variant.id
+        image_id = parse_json(response.body)['data']['id']
+        expect(image_id).to eql image.id.to_s
+      end
+
+      it 'will not show another products image' do
+        get :show, id: image.id, variant_id: new_variant.id
+        expect(response).to have_http_status 404
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/line_items_controller_spec.rb

@@ -0,0 +1,101 @@
+describe Spree::Api::V2::LineItemsController do
+  routes { Spree::Core::Engine.routes }
+
+  let(:order) { create :order }
+  let(:user) { order.user }
+  let(:variant) { create :variant }
+
+  before { user.generate_spree_api_key! }
+
+  describe '#create' do
+    let(:line_item_data) do
+      {
+        attributes: {
+          order_id: order.id,
+          variant_id: variant.id,
+          quantity: 1
+        }
+      }
+    end
+
+    context 'on success' do
+      it 'will respond with line item' do
+        post :create, token: user.spree_api_key, data: line_item_data
+        expect(JSON.parse(response.body)['data']['type']).to eql 'spree_line_items'
+      end
+    end
+
+    context 'when out of range' do
+      before do
+        line_item_data[:attributes][:quantity] = 123_123_123_123
+        post :create, token: user.spree_api_key, data: line_item_data
+      end
+
+      it 'will respond with quantity too high error' do
+        expect(response.body).to be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "code": "400",
+                "detail" : #{Spree.t('api.errors.quantity_too_high.detail').gsub("\n", '').to_json},
+                "meta" : {},
+                "status": "Bad Request",
+                "title" : #{Spree.t('api.errors.quantity_too_high.title').titleize.to_json}
+              }
+            ]
+          }
+        JSON
+      end
+    end
+
+    context 'when record not found' do
+      before do
+        line_item_data[:attributes][:order_id] = 0
+        post :create, token: user.spree_api_key, data: line_item_data
+      end
+
+      it 'will respond with record not found error' do
+        expect(response.body).to be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "code": "400",
+                "detail" : #{Spree.t('api.errors.record_not_found.detail').gsub("\n", '').to_json},
+                "meta" : {},
+                "status": "Bad Request",
+                "title" : #{Spree.t('api.errors.record_not_found.title').to_json}
+              }
+            ]
+          }
+        JSON
+      end
+    end
+
+    context 'when record is invalid' do
+      let(:stock_item) { variant.stock_items.first }
+
+      before do
+        quantity = stock_item.count_on_hand + 1
+        stock_item.update(backorderable: false)
+        line_item_data[:attributes][:quantity] = quantity
+        post :create, token: user.spree_api_key, data: line_item_data
+      end
+
+      it 'will respond with product out of stock' do
+        expect(response.body).to be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "code": "400",
+                "detail" : "#{Spree.t('api.errors.product_out_of_stock.detail').gsub("\n", '')}",
+                "meta" : {},
+                "status": "Bad Request",
+                "title" : #{Spree.t('api.errors.product_out_of_stock.title').titleize.to_json}
+              }
+            ]
+          }
+        JSON
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/option_types_controller_spec.rb

@@ -0,0 +1,71 @@
+describe Spree::Api::V2::OptionTypesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:option_type) { create :option_type }
+  let(:product) { create :product, option_types: [option_type] }
+  let(:new_product) { create :product }
+
+  describe '#index' do
+    it 'will list all option types' do
+      get :index
+      option_type_ids = parse_json(response.body)['data'].map do |option_type|
+        option_type['id']
+      end
+      expect(option_type_ids).to include option_type.id.to_s
+    end
+
+    context 'by product' do
+      it 'will list option types' do
+        get :index, product_id: product.id
+        option_type_ids = parse_json(response.body)['data'].map do |option_type|
+          option_type['id']
+        end
+        expect(option_type_ids).to include option_type.id.to_s
+      end
+
+      it 'will not list option types belonging to a different product' do
+        get :index, product_id: new_product.id
+        data = parse_json(response.body)['data']
+        expect(data).to be_empty
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will find selected option_type by id' do
+      get :show, id: option_type.id
+      option_type_id = parse_json(response.body)['data']['id']
+      expect(option_type_id).to eql option_type.id.to_s
+    end
+
+    context 'by product' do
+      it 'will list option types' do
+        get :show, id: option_type.id, product_id: product.id
+        option_type_id = parse_json(response.body)['data']['id']
+        expect(option_type_id).to eql option_type.id.to_s
+      end
+
+      it 'will not list option types belonging to a different product' do
+        get :show, id: option_type.id, product_id: new_product.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by option value' do
+      let(:option_value) { create :option_value, option_type: option_type }
+      let(:new_option_value) { create :option_value }
+
+      it 'will list option types' do
+        get :show, option_value_id: option_value.id
+        option_type_id = parse_json(response.body)['data']['id']
+        expect(option_type_id).to eql option_type.id.to_s
+      end
+
+      it 'will not list option types belonging to a different option value' do
+        get :show, option_value_id: new_option_value.id
+        option_type_id = parse_json(response.body)['data']['id']
+        expect(option_type_id).to_not eql option_type.id.to_s
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/option_values_controller_spec.rb

@@ -0,0 +1,88 @@
+describe Spree::Api::V2::OptionValuesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:option_value) { create :option_value }
+  let(:new_option_value) { create :option_value }
+  let(:variant) { create :variant, option_values: [option_value] }
+  let(:new_variant) { create :variant }
+
+  describe '#index' do
+    it 'will list all option values' do
+      get :index
+      option_value_ids = parse_json(response.body)['data'].map do |option_value|
+        option_value['id']
+      end
+      expect(option_value_ids).to include option_value.id.to_s
+    end
+
+    context 'by option type' do
+      it 'will list all option values' do
+        get :index, option_type_id: option_value.option_type.id
+        option_value_ids = parse_json(response.body)['data'].map do |option_value|
+          option_value['id']
+        end
+        expect(option_value_ids).to include option_value.id.to_s
+      end
+
+      it 'will not list option value belonging to a different option type' do
+        get :index, option_type_id: new_option_value.option_type.id
+        option_value_ids = parse_json(response.body)['data'].map do |option_value|
+          option_value['id']
+        end
+        expect(option_value_ids).to_not include option_value.id.to_s
+      end
+    end
+
+    context 'by variant' do
+      it 'will list all option values' do
+        get :index, variant_id: variant.id
+        option_value_ids = parse_json(response.body)['data'].map do |option_value|
+          option_value['id']
+        end
+        expect(option_value_ids).to include option_value.id.to_s
+      end
+
+      it 'will not list option value belonging to a different variant' do
+        get :index, variant_id: new_variant.id
+        option_value_ids = parse_json(response.body)['data'].map do |option_value|
+          option_value['id']
+        end
+        expect(option_value_ids).to_not include option_value.id.to_s
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will find selected option value by id' do
+      get :show, id: option_value.id
+      option_value_id = parse_json(response.body)['data']['id']
+      expect(option_value_id).to eql option_value.id.to_s
+    end
+
+    context 'by option type' do
+      it 'will find option value by option type' do
+        get :show, option_type_id: option_value.option_type.id, id: option_value.id
+        option_value_id = parse_json(response.body)['data']['id']
+        expect(option_value_id).to eql option_value.id.to_s
+      end
+
+      it 'will not find option value belonging to a different option type' do
+        get :show, option_type_id: new_option_value.option_type.id, id: option_value.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by variant' do
+      it 'will find option value by option type' do
+        get :show, variant_id: variant.id, id: option_value.id
+        option_value_id = parse_json(response.body)['data']['id']
+        expect(option_value_id).to eql option_value.id.to_s
+      end
+
+      it 'will not find option value belonging to a different option type' do
+        get :show, variant_id: new_variant.id, id: option_value.id
+        expect(response).to have_http_status 404
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/orders_controller_spec.rb

@@ -0,0 +1,61 @@
+describe Spree::Api::V2::OrdersController do
+  routes { Spree::Core::Engine.routes }
+
+  let(:order) { create :order }
+  let(:user) { order.user }
+  let(:admin) { create :admin_user }
+
+  before { user.generate_spree_api_key! }
+
+  describe '#index' do
+    context 'when admin' do
+      before { admin.generate_spree_api_key! }
+
+      it 'will list all orders' do
+        get :index, token: admin.spree_api_key
+        ids = JSON.parse(response.body)['data'].map { |d| d['id'].to_i }
+        expect(ids).to include order.id
+      end
+    end
+
+    context 'when user' do
+      let!(:new_order) { create :order }
+
+      before { get :index, token: user.spree_api_key }
+
+      it 'will not list another users order' do
+        ids = JSON.parse(response.body)['data'].map { |d| d['id'].to_i }
+        expect(ids).to_not include new_order.id
+      end
+
+      it 'will list the current users orders' do
+        ids = JSON.parse(response.body)['data'].map { |d| d['id'].to_i }
+        expect(ids).to include order.id
+      end
+    end
+  end
+
+  describe '#show' do
+    context 'when admin' do
+      before { admin.generate_spree_api_key! }
+
+      it 'can respond with another users order' do
+        get :show, token: admin.spree_api_key, id: order.id
+        expect(JSON.parse(response.body)['data']['type']).to eql 'spree_orders'
+      end
+    end
+
+    context 'when user' do
+      it 'will not respond with another users order' do
+        new_order = create :order
+        get :show, token: user.spree_api_key, id: new_order.id
+        expect(response).to have_http_status 404
+      end
+
+      it 'will respond with the current users order' do
+        get :show, token: user.spree_api_key, id: order.id
+        expect(JSON.parse(response.body)['data']['id'].to_i).to eql order.id
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/prices_controller_spec.rb

@@ -0,0 +1,55 @@
+describe Spree::Api::V2::PricesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:price) { create :price }
+  let(:new_variant) { create :variant }
+
+  describe '#index' do
+    it 'will list all prices' do
+      get :index
+      price_ids = parse_json(response.body)['data'].map do |price|
+        price['id']
+      end
+      expect(price_ids).to include price.id.to_s
+    end
+
+    context 'by variant id' do
+      it 'will list its prices' do
+        get :index, variant_id: price.variant.id
+        price_ids = parse_json(response.body)['data'].map do |price|
+          price['id']
+        end
+        expect(price_ids).to include price.id.to_s
+      end
+
+      it 'will not list another variants prices' do
+        get :index, variant_id: new_variant.id
+        price_ids = parse_json(response.body)['data'].map do |price|
+          price['id']
+        end
+        expect(price_ids).to_not include price.id.to_s
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will show the price' do
+      get :show, id: price.id
+      price_id = parse_json(response.body)['data']['id']
+      expect(price_id).to eql price.id.to_s
+    end
+
+    context 'by variant id' do
+      it 'will show its prices' do
+        get :show, id: price.id, variant_id: price.variant.id
+        price_id = parse_json(response.body)['data']['id']
+        expect(price_id).to eql price.id.to_s
+      end
+
+      it 'will not show another variants price' do
+        get :show, id: price.id, variant_id: new_variant.id
+        expect(response).to have_http_status 404
+      end
+    end
+  end
+end

data/spec/controllers/spree/api/v2/products_controller_spec.rb

@@ -0,0 +1,99 @@
+describe Spree::Api::V2::ProductsController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:product) { create :product }
+  let(:taxon) { create :taxon, products: [product] }
+  let(:new_taxon) { create :taxon }
+
+  describe '#index' do
+    it 'will respond with products' do
+      get :index
+      expect(JSON.parse(response.body)['data'].size).to eql 1
+    end
+
+    context 'by taxon id' do
+      it 'will respond with the taxons products' do
+        get :index, taxon_id: taxon.id
+        product_ids = parse_json(response.body)['data'].map do |products|
+          products['id']
+        end
+        expect(product_ids).to include product.id.to_s
+      end
+
+      it 'will not respond with a product that is not associated to the taxon' do
+        get :index, taxon_id: new_taxon.id
+        data = parse_json(response.body)['data']
+        expect(data).to be_empty
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will render the selected product' do
+      get :show, id: product.id
+      expect(parse_json(response.body)['data']['id']).to eql product.id.to_s
+    end
+
+    it 'can find a product by slug' do
+      get :show, id: product.slug
+      product_id = parse_json(response.body)['data']['id']
+      expect(product_id).to eql product.id.to_s
+    end
+
+    context 'by taxon id' do
+      it 'will respond with the taxons products' do
+        get :show, taxon_id: taxon.id, id: product.id
+        product_id = parse_json(response.body)['data']['id']
+        expect(product_id).to eql product.id.to_s
+      end
+
+      it 'will not respond with a product that is not associated to the taxon' do
+        get :show, taxon_id: new_taxon.id, id: product.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by option type' do
+      let(:option_type) { create :option_type, products: [product] }
+      let(:new_option_type) { create :option_type }
+
+      it 'will find product' do
+        get :show, option_type_id: option_type.id, id: product.id
+        product_id = parse_json(response.body)['data']['id']
+        expect(product_id).to eql product.id.to_s
+      end
+
+      it 'will not find a product belong to a different option type' do
+        get :show, option_type_id: new_option_type.id, id: product.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by variant id' do
+      it 'will show its product' do
+        get :show, variant_id: product.master.id
+        product_id = parse_json(response.body)['data']['id']
+        expect(product_id).to eql product.id.to_s
+      end
+    end
+
+    context 'by price id' do
+      it 'will show its product' do
+        get :show, price_id: product.master.prices.first.id
+        product_id = parse_json(response.body)['data']['id']
+        expect(product_id).to eql product.id.to_s
+      end
+    end
+
+    context 'by image id' do
+      let(:image) { create :image }
+
+      it 'will show its product' do
+        product.images << image
+        get :show, image_id: image.id
+        product_id = parse_json(response.body)['data']['id']
+        expect(product_id).to eql product.id.to_s
+      end
+    end
+  end
+end