solidus_api_v2 0.2.0

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

@@ -0,0 +1,108 @@
+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 variants' do
+        get :index, option_value_id: new_option_value.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
+  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/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,116 @@
+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
+  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,
+            "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,69 @@
+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,
+            "considered_risky" : 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" : 0,
+            "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

data/spec/serializers/spree/price_serializer_spec.rb

@@ -0,0 +1,28 @@
+describe Spree::PriceSerializer do
+  let(:price) { create :price }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new price) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "amount" : "19.99",
+            "currency" : "USD",
+            "display_amount" : "$19.99",
+            "display_price" : "$19.99",
+            "price" : "19.99"
+          },
+          "relationships" : {
+            "variant" : {
+              "data" : {
+                "type" : "spree_variants"
+              }
+            }
+          },
+          "type" : "spree_prices"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/product_serializer_spec.rb

@@ -0,0 +1,47 @@
+describe Spree::ProductSerializer do
+  let(:image) { create :image }
+  let(:product) { create :product }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new product) }
+
+  before { product.images << image }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "description" : #{product.description.to_json},
+            "meta_description" : null,
+            "meta_keywords" : null,
+            "name" : "#{product.name}",
+            "slug" : "#{product.slug}"
+          },
+          "relationships" : {
+            "images" : {
+              "data" : [
+                {
+                  "type" : "spree_images"
+                }
+              ]
+            },
+            "master" : {
+              "data" : {
+                "type" : "spree_variants"
+              }
+            },
+            "option_types" : {
+              "data" : []
+            },
+            "taxons" : {
+              "data" : []
+            },
+            "variants" : {
+              "data" : []
+            }
+          },
+          "type" : "spree_products"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/role_serializer_spec.rb

@@ -0,0 +1,17 @@
+describe Spree::RoleSerializer do
+  let(:role) { create :role }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new role) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "name" : "#{role.name}"
+          },
+          "type" : "spree_roles"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/state_serializer_spec.rb

@@ -0,0 +1,25 @@
+describe Spree::StateSerializer do
+  let(:state) { create :state }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new state) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+          "attributes" : {
+            "abbr" : "#{state.abbr}",
+            "name" : "#{state.name}"
+          },
+          "relationships" : {
+            "country" : {
+              "data" : {
+                "type" : "spree_countries"
+              }
+            }
+          },
+          "type" : "spree_states"
+        }
+      }
+    JSON
+  end
+end

data/spec/serializers/spree/store_serializer_spec.rb

@@ -0,0 +1,25 @@
+describe Spree::StoreSerializer do
+  let(:store) { create :store }
+  subject { ActiveModel::Serializer::Adapter::JsonApi.new(described_class.new store) }
+
+  its(:to_json) do
+    is_expected.to be_json_eql <<-JSON
+      {
+        "data" : {
+           "attributes" : {
+             "code" : "#{store.code}",
+             "default" : #{store.default},
+             "default_currency" : #{store.default_currency || 'null'},
+             "mail_from_address" : "#{store.mail_from_address}",
+             "meta_description" : null,
+             "meta_keywords" : null,
+             "name" : "#{store.name}",
+             "seo_title" : null,
+             "url" : "#{store.url}"
+           },
+           "type" : "spree_stores"
+         }
+       }
+    JSON
+  end
+end