solidus_api 2.10.5 → 2.11.0

data/spec/requests/spree/api/classifications_controller_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::ClassificationsController, type: :request do
-    let(:taxon) do
-      taxon = create(:taxon)
-
-      3.times do
-        product = create(:product)
-        product.taxons << taxon
-      end
-      taxon
-    end
-
-    before do
-      stub_authentication!
-    end
-
-    context "as a user" do
-      it "cannot change the order of a product" do
-        put spree.api_classifications_path, params: { taxon_id: taxon, product_id: taxon.products.first, position: 1 }
-        expect(response.status).to eq(401)
-      end
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      let(:last_product) { taxon.products.last }
-
-      it "can change the order a product" do
-        classification = taxon.classifications.find_by(product_id: last_product.id)
-        expect(classification.position).to eq(3)
-        put spree.api_classifications_path, params: { taxon_id: taxon.id, product_id: last_product.id, position: 0 }
-        expect(response.status).to eq(200)
-        expect(classification.reload.position).to eq(1)
-      end
-
-      it "should touch the taxon" do
-        taxon.update(updated_at: Time.current - 10.seconds)
-        taxon_last_updated_at = taxon.updated_at
-        put spree.api_classifications_path, params: { taxon_id: taxon.id, product_id: last_product.id, position: 0 }
-        taxon.reload
-        expect(taxon_last_updated_at.to_i).to_not eq(taxon.updated_at.to_i)
-      end
-    end
-  end
-end

data/spec/requests/spree/api/config_controller_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::ConfigController, type: :request do
-    let!(:default_country) { create :country, iso: "US" }
-
-    before do
-      stub_authentication!
-    end
-
-    it "returns Spree::Money settings" do
-      get '/api/config/money'
-      expect(response).to be_successful
-      expect(json_response["symbol"]).to eq("$")
-    end
-
-    it "returns some configuration settings" do
-      get '/api/config'
-      expect(response).to be_successful
-      expect(json_response["default_country_iso"]).to eq("US")
-      expect(json_response["default_country_id"]).to eq(default_country.id)
-    end
-  end
-end

data/spec/requests/spree/api/countries_controller_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::CountriesController, type: :request do
-    before do
-      stub_authentication!
-      @state = create(:state)
-      @country = @state.country
-    end
-
-    it "gets all countries" do
-      get spree.api_countries_path
-      expect(json_response['countries'].first['iso3']).to eq @country.iso3
-    end
-
-    context "with two countries" do
-      before { @zambia = create(:country, name: "Zambia") }
-
-      it "can view all countries" do
-        get spree.api_countries_path
-        expect(json_response['count']).to eq(2)
-        expect(json_response['current_page']).to eq(1)
-        expect(json_response['pages']).to eq(1)
-      end
-
-      it 'can query the results through a paramter' do
-        get spree.api_countries_path, params: { q: { name_cont: 'zam' } }
-        expect(json_response['count']).to eq(1)
-        expect(json_response['countries'].first['name']).to eq @zambia.name
-      end
-
-      it 'can control the page size through a parameter' do
-        get spree.api_countries_path, params: { 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
-    end
-
-    it "includes states" do
-      get spree.api_country_path(@country.id)
-      states = json_response['states']
-      expect(states.first['name']).to eq @state.name
-    end
-  end
-end

data/spec/requests/spree/api/coupon_codes_controller_spec.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::CouponCodesController, type: :request do
-    let(:current_api_user) do
-      user = Spree.user_class.new(email: "spree@example.com")
-      user.generate_spree_api_key!
-      user
-    end
-
-    before do
-      stub_authentication!
-    end
-
-    describe '#create' do
-      let(:promo) { create(:promotion_with_item_adjustment, code: 'night_melody') }
-      let(:promo_code) { promo.codes.first }
-
-      before do
-        allow_any_instance_of(Order).to receive_messages user: current_api_user
-      end
-
-      context 'when successful' do
-        let(:order) { create(:order_with_line_items) }
-
-        it 'applies the coupon' do
-          post spree.api_order_coupon_codes_path(order), params: { coupon_code: promo_code.value }
-
-          expect(response.status).to eq(200)
-          expect(order.reload.promotions).to eq([promo])
-          expect(json_response).to eq({
-            "success" => I18n.t('spree.coupon_code_applied'),
-            "error" => nil,
-            "successful" => true,
-            "status_code" => "coupon_code_applied"
-          })
-        end
-      end
-
-      context 'when unsuccessful' do
-        let(:order) { create(:order) }
-
-        it 'returns an error' do
-          post spree.api_order_coupon_codes_path(order), params: { coupon_code: promo_code.value }
-
-          expect(response.status).to eq(422)
-          expect(order.reload.promotions).to eq([])
-          expect(json_response).to eq({
-            "success" => nil,
-            "error" => I18n.t('spree.coupon_code_unknown_error'),
-            "successful" => false,
-            "status_code" => "coupon_code_unknown_error"
-          })
-        end
-      end
-    end
-
-    describe '#destroy' do
-      let(:promo) {
-        create(:promotion_with_item_adjustment,
-               code: 'tenoff',
-               per_code_usage_limit: 5,
-               adjustment_rate: 10)
-      }
-
-      let(:promo_code) { promo.codes.first }
-      let(:order) { create(:order_with_line_items, user: current_api_user) }
-
-      before do
-        post spree.api_order_coupon_codes_path(order), params: { coupon_code: promo_code.value }
-        delete spree.api_order_coupon_code_path(order, promo_code.value)
-      end
-
-      context 'when successful' do
-        it 'removes the coupon' do
-          expect(response.status).to eq(200)
-          expect(order.reload.promotions).to eq([])
-          expect(json_response).to eq({
-            "success" => I18n.t('spree.coupon_code_removed'),
-            "error" => nil,
-            "successful" => true,
-            "status_code" => "coupon_code_removed"
-          })
-        end
-      end
-
-      context 'when unsuccessful' do
-        it 'returns an error' do
-          delete spree.api_order_coupon_code_path(order, promo_code.value)
-
-          expect(response.status).to eq(422)
-          expect(order.reload.promotions).to eq([])
-          expect(json_response).to eq({
-            "success" => nil,
-            "error" => I18n.t('spree.coupon_code_not_present'),
-            "successful" => false,
-            "status_code" => "coupon_code_not_present"
-          })
-        end
-      end
-    end
-  end
-end

data/spec/requests/spree/api/credit_cards_controller_spec.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::CreditCardsController, type: :request do
-    describe '#index' do
-      let!(:admin_user) do
-        create(:admin_user)
-      end
-
-      let!(:normal_user) do
-        create(:user, :with_api_key)
-      end
-
-      let!(:card) { create(:credit_card, user_id: admin_user.id, gateway_customer_profile_id: "random") }
-
-      before do
-        stub_authentication!
-      end
-
-      it "the user id doesn't exist" do
-        get spree.api_user_credit_cards_path(1000)
-        expect(response.status).to eq(404)
-      end
-
-      context "calling user is in admin role" do
-        let(:current_api_user) do
-          admin_user
-        end
-
-        it "no credit cards exist for user" do
-          get spree.api_user_credit_cards_path(normal_user)
-
-          expect(response.status).to eq(200)
-          expect(json_response["pages"]).to eq(0)
-        end
-
-        it "can view all credit cards for user" do
-          get spree.api_user_credit_cards_path(current_api_user.id)
-
-          expect(response.status).to eq(200)
-          expect(json_response["pages"]).to eq(1)
-          expect(json_response["current_page"]).to eq(1)
-          expect(json_response["credit_cards"].length).to eq(1)
-          expect(json_response["credit_cards"].first["id"]).to eq(card.id)
-        end
-      end
-
-      context "calling user is not in admin role" do
-        let(:current_api_user) do
-          normal_user
-        end
-
-        let!(:card) { create(:credit_card, user_id: normal_user.id, gateway_customer_profile_id: "random") }
-
-        it "can not view user" do
-          get spree.api_user_credit_cards_path(admin_user.id)
-
-          expect(response.status).to eq(404)
-        end
-
-        it "can view own credit cards" do
-          get spree.api_user_credit_cards_path(normal_user.id)
-
-          expect(response.status).to eq(200)
-          expect(json_response["pages"]).to eq(1)
-          expect(json_response["current_page"]).to eq(1)
-          expect(json_response["credit_cards"].length).to eq(1)
-          expect(json_response["credit_cards"].first["id"]).to eq(card.id)
-        end
-      end
-    end
-
-    describe '#update' do
-      let(:credit_card) { create(:credit_card, name: 'Joe Shmoe', user: credit_card_user) }
-      let(:credit_card_user) { create(:user) }
-
-      before do
-        stub_authentication!
-      end
-
-      context 'when the user is authorized' do
-        let(:current_api_user) { credit_card_user }
-
-        it 'updates the credit card' do
-          expect {
-            put spree.api_credit_card_path(credit_card.to_param), params: { credit_card: { name: 'Jordan Brough' } }
-          }.to change {
-            credit_card.reload.name
-          }.from('Joe Shmoe').to('Jordan Brough')
-        end
-      end
-
-      context 'when the user is not authorized' do
-        let(:current_api_user) { create(:user) }
-
-        it 'rejects the request' do
-          put spree.api_credit_card_path(credit_card.to_param), params: { credit_card: { name: 'Jordan Brough' } }
-          expect(response.status).to eq(401)
-        end
-      end
-    end
-  end
-end

data/spec/requests/spree/api/images_controller_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Spree::Api::ImagesController, type: :request do
-    let!(:product) { create(:product) }
-    let!(:attributes) {
-      [:id, :position, :attachment_content_type,
-       :attachment_file_name, :type, :attachment_updated_at, :attachment_width,
-       :attachment_height, :alt]
-    }
-
-    before do
-      stub_authentication!
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-
-      it "can upload a new image for a variant" do
-        expect do
-          post spree.api_product_images_path(product.id), params: {
-            image: {
-              attachment: upload_image('thinking-cat.jpg'),
-              viewable_type: 'Spree::Variant',
-              viewable_id: product.master.to_param
-            },
-          }
-          expect(response.status).to eq(201)
-          expect(json_response).to have_attributes(attributes)
-        end.to change(Image, :count).by(1)
-      end
-
-      context "working with an existing image" do
-        let!(:product_image) { product.master.images.create!(attachment: image('thinking-cat.jpg')) }
-
-        it "can get a single product image" do
-          get spree.api_product_image_path(product.id, product_image)
-          expect(response.status).to eq(200)
-          expect(json_response).to have_attributes(attributes)
-        end
-
-        it "can get a single variant image" do
-          get spree.api_variant_image_path(product.master.id, product_image)
-          expect(response.status).to eq(200)
-          expect(json_response).to have_attributes(attributes)
-        end
-
-        it "can get a list of product images" do
-          get spree.api_product_images_path(product.id)
-          expect(response.status).to eq(200)
-          expect(json_response).to have_key("images")
-          expect(json_response["images"].first).to have_attributes(attributes)
-        end
-
-        it "can get a list of variant images" do
-          get spree.api_variant_images_path(product.master.id)
-          expect(response.status).to eq(200)
-          expect(json_response).to have_key("images")
-          expect(json_response["images"].first).to have_attributes(attributes)
-        end
-
-        it "can update image data" do
-          expect(product_image.position).to eq(1)
-          put spree.api_variant_image_path(product.id, product_image), params: { image: { position: 2 } }
-          expect(response.status).to eq(200)
-          expect(json_response).to have_attributes(attributes)
-          expect(product_image.reload.position).to eq(2)
-        end
-
-        it "can delete an image" do
-          delete spree.api_variant_image_path(product.id, product_image)
-          expect(response.status).to eq(204)
-          expect { product_image.reload }.to raise_error(ActiveRecord::RecordNotFound)
-        end
-      end
-    end
-
-    context "as a non-admin" do
-      let(:product_image) { product.master.images.create!(attachment: image('thinking-cat.jpg')) }
-
-      it "cannot create an image" do
-        post spree.api_product_images_path(product.id)
-        assert_unauthorized!
-      end
-
-      it "cannot update an image" do
-        put spree.api_product_image_path(product.id, product_image)
-        assert_not_found!
-      end
-
-      it "cannot delete an image" do
-        delete spree.api_product_image_path(product.id, product_image)
-        assert_not_found!
-      end
-    end
-  end
-end

data/spec/requests/spree/api/inventory_units_controller_spec.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Api::InventoryUnitsController, type: :request do
-    let!(:inventory_unit) { create(:inventory_unit) }
-
-    before do
-      stub_authentication!
-    end
-
-    context "as an admin" do
-      sign_in_as_admin!
-      let(:variant) { create(:variant) }
-
-      it "gets an inventory unit" do
-        get spree.api_inventory_unit_path(inventory_unit)
-        expect(json_response['state']).to eq inventory_unit.state
-      end
-
-      it "updates an inventory unit" do
-        put spree.api_inventory_unit_path(inventory_unit), params: {
-          inventory_unit: { variant_id: variant.id }
-        }
-        expect(json_response['variant_id']).to eq variant.id
-      end
-
-      context 'fires state event' do
-        it 'if supplied with :fire param' do
-          put spree.api_inventory_unit_path(inventory_unit), params: {
-            fire: 'ship',
-            inventory_unit: { variant_id: variant.id }
-          }
-
-          expect(json_response['state']).to eq 'shipped'
-        end
-
-        it 'and returns exception if cannot fire' do
-          put spree.api_inventory_unit_path(inventory_unit), params: {
-            fire: 'return'
-          }
-          expect(json_response['exception']).to match /cannot transition to return/
-        end
-
-        it 'and returns exception bad state' do
-          put spree.api_inventory_unit_path(inventory_unit), params: {
-            fire: 'bad'
-          }
-          expect(json_response['exception']).to match /cannot transition to bad/
-        end
-      end
-    end
-  end
-end