solidus_api_v2 0.2.0

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,93 @@
+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
+        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
+
+    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,86 @@
+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_params) { { order_id: order.id, variant_id: variant.id, quantity: 1 } }
+
+    context 'on success' do
+      it 'will respond with line item' do
+        post :create, token: user.spree_api_key, line_item: line_item_params
+        expect(JSON.parse(response.body)['data']['type']).to eql 'spree_line_items'
+      end
+    end
+
+    context 'when out of range' do
+      before do
+        post :create, token: user.spree_api_key,
+                      line_item: line_item_params.merge(quantity: 123_123_123_123)
+      end
+
+      it 'will respond with quantity too high error' do
+        expect(response.body).to be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "detail" : #{Spree.t('api.errors.quantity_too_high.detail').gsub("\n", '').to_json},
+                "meta" : {},
+                "title" : #{Spree.t('api.errors.quantity_too_high.title').titleize.to_json}
+              }
+            ]
+          }
+        JSON
+      end
+    end
+
+    context 'when record not found' do
+      before do
+        post :create, token: user.spree_api_key, line_item: line_item_params.merge(order_id: 0)
+      end
+
+      it 'will respond with record not found error' do
+        expect(response.body).to be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "detail" : #{Spree.t('api.errors.record_not_found.detail').gsub("\n", '').to_json},
+                "meta" : {},
+                "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)
+        post :create, token: user.spree_api_key,
+                      line_item: line_item_params.merge(quantity: quantity)
+      end
+
+      it 'will respond with product out of stock' do
+        expect(response.body).to be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "detail" : "#{Spree.t('api.errors.product_out_of_stock.detail').gsub("\n", '')}",
+                "meta" : {},
+                "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,73 @@
+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
+        option_type_ids = parse_json(response.body)['data'].map do |option_type|
+          option_type['id']
+        end
+        expect(option_type_ids).to_not include option_type.id.to_s
+      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,15 @@
+describe Spree::Api::V2::OrdersController do
+  routes { Spree::Core::Engine.routes }
+
+  let(:order) { create :order }
+  let(:user) { order.user }
+
+  before { user.generate_spree_api_key! }
+
+  describe '#show' do
+    it 'will respond with the order' do
+      get :show, token: user.spree_api_key, id: order.id
+      expect(JSON.parse(response.body)['data']['type']).to eql 'spree_orders'
+    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,95 @@
+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
+        product_ids = parse_json(response.body)['data'].map do |products|
+          products['id']
+        end
+        expect(product_ids).to_not include product.id.to_s
+      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
+
+    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

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

@@ -0,0 +1,42 @@
+describe Spree::Api::V2::StatesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:state) { create :state }
+
+  describe '#index' do
+    it 'can list all states' do
+      get :index
+      expect(JSON.parse(response.body)['data'].length).to eql 1
+    end
+
+    context 'by country id' do
+      it 'will list selected states by country' do
+        get :index, country_id: state.country.id
+        expect(JSON.parse(response.body)['data'].length).to eql 1
+      end
+
+      it 'will not include states belonging to other countries' do
+        new_state = create :state
+        get :index, country_id: state.country.id
+        state_ids = JSON.parse(response.body)['data'].map do |states|
+          states['id']
+        end
+        expect(state_ids).to_not include new_state
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will find selected state by id' do
+      get :show, id: state.id
+      state_id = parse_json(response.body)['data']['id']
+      expect(state_id).to eql state.id.to_s
+    end
+
+    it 'can find a state by a country' do
+      get :show, country_id: state.country.id, id: state.id
+      state_id = parse_json(response.body)['data']['id']
+      expect(state_id).to eql state.id.to_s
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+describe Spree::Api::V2::TaxonomiesController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:taxonomy) { create :taxonomy }
+
+  describe '#index' do
+    it 'will list taxonomies' do
+      get :index
+      taxonomy_ids = parse_json(response.body)['data'].map do |taxonomy|
+        taxonomy['id']
+      end
+      expect(taxonomy_ids).to include taxonomy.id.to_s
+    end
+  end
+
+  describe '#show' do
+    let(:taxon) { taxonomy.root }
+
+    it 'will show taxonomy' do
+      get :show, id: taxonomy.id
+      taxonomy_id = parse_json(response.body)['data']['id']
+      expect(taxonomy_id).to eql taxonomy.id.to_s
+    end
+
+    it 'can show taxonomy by taxon_id' do
+      get :show, taxon_id: taxon.id
+      taxonomy_id = parse_json(response.body)['data']['id']
+      expect(taxonomy_id).to eql taxonomy.id.to_s
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+describe Spree::Api::V2::TaxonsController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:taxon) { create :taxon }
+
+  describe '#index' do
+    it 'will list the taxons' do
+      get :index
+      taxon_ids = parse_json(response.body)['data'].map do |taxon|
+        taxon['id']
+      end
+      expect(taxon_ids).to include taxon.id.to_s
+    end
+
+    it 'can list the taxons filtered by taxonomy_id' do
+      get :index, taxonomy_id: taxon.taxonomy.id
+      taxon_ids = parse_json(response.body)['data'].map do |taxon|
+        taxon['id']
+      end
+      expect(taxon_ids).to include taxon.id.to_s
+    end
+  end
+
+  describe '#show' do
+    it 'will show the selected taxon' do
+      get :show, id: taxon.id
+      taxon_id = parse_json(response.body)['data']['id']
+      expect(taxon_id).to eql taxon.id.to_s
+    end
+
+    context 'by parent' do
+      it 'can show a taxons parent' do
+        child = create :taxon, parent: taxon
+        get :show, taxon_id: child.id
+        taxon_id = parse_json(response.body)['data']['id']
+        expect(taxon_id).to eql taxon.id.to_s
+      end
+    end
+
+    context 'by taxonomy_id' do
+      it 'will fetch the selected taxon' do
+        get :show, taxonomy_id: taxon.taxonomy.id, id: taxon.id
+        taxon_id = parse_json(response.body)['data']['id']
+        expect(taxon_id).to eql taxon.id.to_s
+      end
+
+      it 'when taxon does not belong to taxonomy' do
+        new_taxonomy = create :taxonomy
+        get :show, taxonomy_id: new_taxonomy.id, id: taxon.id
+        expect(response).to have_http_status 404
+      end
+    end
+  end
+end