solidus_json_api 0.3.0

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

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

@@ -0,0 +1,106 @@
+describe Spree::Api::V2::VariantsController do
+  routes { Spree::Core::Engine.routes }
+
+  let!(:variant) { create :variant }
+  let(:new_option_value) { create :option_value }
+
+  describe '#index' do
+    it 'will list all variants' do
+      get :index
+      variant_ids = parse_json(response.body)['data'].map do |variant|
+        variant['id']
+      end
+      expect(variant_ids).to include variant.id.to_s
+    end
+
+    context 'by product id' do
+      let(:new_product) { create :product }
+
+      it 'will list its variants' do
+        get :index, product_id: variant.product.id
+        variant_ids = parse_json(response.body)['data'].map do |variant|
+          variant['id']
+        end
+        expect(variant_ids).to include variant.id.to_s
+      end
+
+      it 'will not list another products variants' do
+        get :index, product_id: new_product.id
+        variant_ids = parse_json(response.body)['data'].map do |variant|
+          variant['id']
+        end
+        expect(variant_ids).to_not include variant.id.to_s
+      end
+    end
+
+    context 'by option value' do
+      it 'will list its variants' do
+        get :index, option_value_id: variant.option_values.first.id
+        variant_ids = parse_json(response.body)['data'].map do |variant|
+          variant['id']
+        end
+        expect(variant_ids).to include variant.id.to_s
+      end
+
+      it 'will not list another products variant' do
+        get :index, option_value_id: new_option_value.id
+        data = parse_json(response.body)['data']
+        expect(data).to be_empty
+      end
+    end
+  end
+
+  describe '#show' do
+    it 'will show the variant' do
+      get :show, id: variant.id
+      variant_id = parse_json(response.body)['data']['id']
+      expect(variant_id).to eql variant.id.to_s
+    end
+
+    context 'by product id' do
+      let(:new_product) { create :product }
+
+      it 'will show its variant' do
+        get :show, id: variant.id, product_id: variant.product.id
+        variant_id = parse_json(response.body)['data']['id']
+        expect(variant_id).to eql variant.id.to_s
+      end
+
+      it 'will not show another products variant' do
+        get :show, id: variant.id, product_id: new_product.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by option_value id' do
+      it 'will show its variant' do
+        get :show, id: variant.id, option_value_id: variant.option_values.first.id
+        variant_id = parse_json(response.body)['data']['id']
+        expect(variant_id).to eql variant.id.to_s
+      end
+
+      it 'will not show another option_values variant' do
+        get :show, id: variant.id, option_value_id: new_option_value.id
+        expect(response).to have_http_status 404
+      end
+    end
+
+    context 'by price id' do
+      it 'will show its variant' do
+        get :show, price_id: variant.prices.first.id
+        variant_id = parse_json(response.body)['data']['id']
+        expect(variant_id).to eql variant.id.to_s
+      end
+    end
+
+    context 'by image id' do
+      let(:image) { create :image, viewable: variant }
+
+      it 'will show its variant' do
+        get :show, image_id: image.id
+        variant_id = parse_json(response.body)['data']['id']
+        expect(variant_id).to eql variant.id.to_s
+      end
+    end
+  end
+end

data/spec/lib/solidus_json_api/config_spec.rb

@@ -0,0 +1,10 @@
+describe SolidusJsonApi do
+  describe '.setup' do
+    it 'can set the parent serializer' do
+      class DescendantOfAMS < ActiveModel::Serializer; end
+
+      described_class.setup { |c| c.parent_serializer = DescendantOfAMS }
+      expect(described_class.parent_serializer).to eql DescendantOfAMS
+    end
+  end
+end

data/spec/models/spree/base_decorator_spec.rb

@@ -0,0 +1,9 @@
+describe Spree::Base do
+  it '.paginate' do
+    # The pagination is concerned onto abstract models. There's not really a way
+    # to be able to ensure that the model is paginated, so instead of ensuring
+    # that the result is paginated (tested in the Spree::Api::BaseController),
+    # this just makes sure it can respond to the +.paginate+ method.
+    expect(described_class).to respond_to(:paginate).with(1).argument
+  end
+end

data/spec/models/spree/price_decorator_spec.rb

@@ -0,0 +1,3 @@
+describe Spree::Price do
+  it { is_expected.to delegate_method(:product).to :variant }
+end

data/spec/serializers/spree/address_serializer_spec.rb

@@ -0,0 +1,35 @@
+describe Spree::AddressSerializer do
+  let(:address) { create :address }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new address) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "address1" : "#{address.address1}",
+            "address2" : "#{address.address2}",
+            "city" : "#{address.city}",
+            "first_name" : "#{address.first_name}",
+            "last_name" : "#{address.last_name}",
+            "phone" : "#{address.phone}",
+            "zipcode" : "#{address.zipcode}"
+          },
+          "relationships" : {
+            "country" : {
+              "data" : {
+                "type" : "spree_countries"
+              }
+            },
+            "state" : {
+              "data" : {
+                "type" : "spree_states"
+              }
+            }
+          },
+          "type" : "spree_addresses"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/country_serializer_spec.rb

@@ -0,0 +1,27 @@
+describe Spree::CountrySerializer do
+  let(:country) { create :country }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new country) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "iso" : "#{country.iso}",
+            "iso3" : "#{country.iso3}",
+            "iso_name" : "#{country.iso_name}",
+            "name" : "#{country.name}",
+            "numcode" : #{country.numcode},
+            "states_required" : #{country.states_required}
+          },
+          "relationships" : {
+            "states" : {
+              "data" : []
+            }
+          },
+          "type" : "spree_countries"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/error_serializer_spec.rb

@@ -0,0 +1,141 @@
+describe Spree::ErrorSerializer do
+  let(:address_errors) do
+    [
+      {
+        "ship_address.firstname": ["can't be blank"],
+        "ship_address.lastname": ["can't be blank"]
+      },
+      {
+        "bill_address.firstname": ["can't be blank"],
+        "bill_address.lastname": ["can't be blank"]
+      }
+    ]
+  end
+
+  subject { described_class }
+
+  describe '#as_json' do
+    before do
+      @store = build(:store, code: nil, mail_from_address: nil)
+      @store.save
+    end
+
+    it 'will format json to json api spec' do
+      expect(described_class.new(@store).as_json).to be_json_eql <<-JSON
+        {
+          "errors": [
+            {
+              "title": "Code",
+              "meta": {},
+              "pointer": "data/attributes/code",
+              "detail": "can't be blank"
+            },
+            {
+              "title": "Mail From Address",
+              "meta": {},
+              "pointer": "data/attributes/mail_from_address",
+              "detail": "can't be blank"
+            }
+          ]
+        }
+      JSON
+    end
+
+    it 'will format options as meta' do
+      expect(described_class.new(@store, example: :content).as_json).to be_json_eql <<-JSON
+        {
+          "errors": [
+            {
+              "detail": "can't be blank",
+              "meta": {
+                "example": "content"
+              },
+              "pointer": "data/attributes/code",
+              "title": "Code"
+            },
+            {
+              "detail": "can't be blank",
+              "meta": {
+                "example": "content"
+              },
+              "pointer": "data/attributes/mail_from_address",
+              "title": "Mail From Address"
+            }
+          ]
+        }
+      JSON
+    end
+
+    it 'will format a symbol' do
+      expect(described_class.new(:invalid_token).as_json).to be_json_eql <<-JSON
+        {
+          "errors": [
+            {
+              "detail": "#{Spree.t('api.errors.invalid_token.detail')}",
+              "meta": {},
+              "title": "#{Spree.t('api.errors.invalid_token.title')}"
+            }
+          ]
+        }
+      JSON
+    end
+
+    it 'will format an array of errors' do
+      expect(described_class.new(address_errors).as_json).to be_json_eql <<-JSON
+        {
+          "errors" : [
+            {
+              "detail" : "can't be blank",
+              "meta" : {},
+              "pointer" : "data/attributes/ship_address/firstname",
+              "title" : "Ship Address Firstname"
+            },
+            {
+              "detail" : "can't be blank",
+              "meta" : {},
+              "pointer" : "data/attributes/ship_address/lastname",
+              "title" : "Ship Address Lastname"
+            },
+            {
+              "detail" : "can't be blank",
+              "meta" : {},
+              "pointer" : "data/attributes/bill_address/firstname",
+              "title" : "Bill Address Firstname"
+            },
+            {
+              "detail" : "can't be blank",
+              "meta" : {},
+              "pointer" : "data/attributes/bill_address/lastname",
+              "title" : "Bill Address Lastname"
+            }
+          ]
+        }
+      JSON
+    end
+
+    context 'can set a response when it is present' do
+      let(:response) do
+        Response ||= Struct.new(:status_message, :code)
+        Response.new('OK', 200)
+      end
+
+      subject { described_class.new(:test, response: response).as_json }
+
+      it do
+        should be_json_eql <<-JSON
+          {
+            "errors" : [
+              {
+                "code" : 200,
+                "detail" : #{Spree.t('api.errors.test.detail').to_json},
+                "meta" : {},
+                "status" : "OK",
+                "title" : #{Spree.t('api.errors.test.title').titleize.to_json}
+              }
+            ]
+          }
+        JSON
+      end
+    end
+  end
+end

data/spec/serializers/spree/image_serializer_spec.rb

@@ -0,0 +1,30 @@
+describe Spree::ImageSerializer do
+  let(:image) { create :image }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new image) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "alt" : null,
+            "links" : {
+              "large" : "#{image.attachment.url(:large)}",
+              "mini" : "#{image.attachment.url(:mini)}",
+              "original" : "#{image.attachment.url(:original)}",
+              "product" : "#{image.attachment.url(:product)}",
+              "small" : "#{image.attachment.url(:small)}"
+            },
+            "position" : 1
+          },
+          "relationships" : {
+            "viewable" : {
+              "data" : null
+            }
+          },
+          "type" : "spree_images"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/line_item_serializer_spec.rb

@@ -0,0 +1,40 @@
+describe Spree::LineItemSerializer do
+  let(:line_item) { create :line_item }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new line_item) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "additional_tax_total" : "0.0",
+            "adjustment_total" : "0.0",
+            "amount" : "10.0",
+            "cost_price" : "17.0",
+            "currency" : "USD",
+            "display_amount" : "$10.00",
+            "display_total" : "$10.00",
+            "order_id" : #{line_item.order_id},
+            "price" : "10.0",
+            "quantity" : 1,
+            "total" : "10.0",
+            "variant_id" : #{line_item.variant_id}
+          },
+          "relationships" : {
+            "order" : {
+              "data" : {
+                "type" : "spree_orders"
+              }
+            },
+            "variant" : {
+              "data" : {
+                "type" : "spree_variants"
+              }
+            }
+          },
+          "type" : "spree_line_items"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/option_type_serializer_spec.rb

@@ -0,0 +1,27 @@
+describe Spree::OptionTypeSerializer do
+  let(:option_type) { create :option_type }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new option_type) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "name" : "#{option_type.name}",
+            "position" : #{option_type.position},
+            "presentation" : "#{option_type.presentation}"
+          },
+          "relationships" : {
+            "option_values" : {
+              "data" : []
+            },
+            "products" : {
+              "data" : []
+            }
+          },
+          "type" : "spree_option_types"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/option_value_serializer_spec.rb

@@ -0,0 +1,29 @@
+describe Spree::OptionValueSerializer do
+  let(:option_value) { create :option_value }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new option_value) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "name" : "#{option_value.name}",
+            "position" : #{option_value.position},
+            "presentation" : "#{option_value.presentation}"
+          },
+          "relationships" : {
+            "option_type" : {
+              "data" : {
+                "type" : "spree_option_types"
+              }
+            },
+            "variants" : {
+              "data" : []
+            }
+          },
+          "type" : "spree_option_values"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/order_serializer_spec.rb

@@ -0,0 +1,68 @@
+describe Spree::OrderSerializer do
+  let(:order) { create :completed_order_with_totals }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new order) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "additional_tax_total" : "0.0",
+            "adjustment_total" : "0.0",
+            "approved_at" : null,
+            "canceled_at" : null,
+            "channel" : "spree",
+            "completed_at" : "#{order.completed_at.iso8601(3)}",
+            "confirmation_delivered" : false,
+            "currency" : "USD",
+            "display_additional_tax_total" : "$0.00",
+            "display_adjustment_total" : "$0.00",
+            "display_included_tax_total" : "$0.00",
+            "display_item_total" : "$10.00",
+            "display_promo_total" : "$0.00",
+            "display_shipment_total" : "$100.00",
+            "display_total" : "$110.00",
+            "email" : "#{order.email}",
+            "included_tax_total" : "0.0",
+            "item_count" : 1,
+            "item_total" : "10.0",
+            "number" : "#{order.number}",
+            "payment_state" : null,
+            "payment_total" : "0.0",
+            "promo_total" : "0.0",
+            "shipment_state" : null,
+            "shipment_total" : "100.0",
+            "special_instructions" : null,
+            "state" : "complete",
+            "total" : "110.0"
+          },
+          "relationships" : {
+            "bill_address" : {
+              "data" : {
+                "type" : "spree_addresses"
+              }
+            },
+            "line_items" : {
+              "data" : [
+                {
+                  "type" : "spree_line_items"
+                }
+              ]
+            },
+            "ship_address" : {
+              "data" : {
+                "type" : "spree_addresses"
+              }
+            },
+            "user" : {
+              "data" : {
+                "type" : "spree_users"
+              }
+            }
+          },
+          "type" : "spree_orders"
+        }
+      }
+    JSON
+  end
+end