solidus_backend_devise_token_auth 2.8.0.alpha.2

data/spec/controllers/spree/admin/prices_controller_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::PricesController do
+  stub_authorization!
+
+  let!(:product) { create(:product) }
+
+  describe '#index' do
+    context "when only given a product" do
+      let(:product) { create(:product) }
+
+      subject { get :index, params: { product_id: product.slug } }
+
+      it { is_expected.to be_successful }
+
+      it 'assigns usable instance variables' do
+        subject
+        expect(assigns(:search)).to be_a(Ransack::Search)
+        expect(assigns(:variant_prices)).to eq(product.prices.for_variant)
+        expect(assigns(:master_prices)).to eq(product.prices.for_master)
+        expect(assigns(:product)).to eq(product)
+      end
+    end
+
+    context "when given a product and a variant" do
+      let(:variant) { create(:variant) }
+      let(:product) { variant.product }
+
+      subject { get :index, params: { product_id: product.slug, variant_id: variant.id } }
+
+      it { is_expected.to be_successful }
+
+      it 'assigns usable instance variables' do
+        subject
+        expect(assigns(:search)).to be_a(Ransack::Search)
+        expect(assigns(:variant_prices)).to eq(product.prices.for_variant)
+        expect(assigns(:master_prices)).to eq(product.prices.for_master)
+        expect(assigns(:variant_prices)).to include(variant.default_price)
+        expect(assigns(:product)).to eq(product)
+      end
+    end
+  end
+end

data/spec/controllers/spree/admin/product_properties_controller_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module Spree
+  module Admin
+    describe ProductPropertiesController, type: :controller do
+      stub_authorization!
+
+      describe "#index" do
+        subject { get :index, params: parameters }
+
+        context "no option values are provided" do
+          let(:product) { create(:product) }
+          let(:parameters) do
+            { product_id: product.to_param }
+          end
+
+          before { subject }
+
+          it "instantiates a new variant property rule" do
+            expect(assigns(:variant_property_rule)).to_not be_persisted
+          end
+
+          it "instantiates a new variant property rule value" do
+            expect(assigns(:variant_property_rule).values.size).to eq 1
+            expect(assigns(:variant_property_rule).values.first).to_not be_persisted
+          end
+        end
+
+        context "option values are provided" do
+          let(:size) { create(:option_type, name: 'size') }
+          let(:product) { create(:product, option_types: [size]) }
+          let(:size_small) { create(:option_value, name: 'small', option_type: size) }
+          let(:size_large) { create(:option_value, name: 'large', option_type: size) }
+          let!(:first_rule) { create(:variant_property_rule, product: product, option_value: size_small) }
+
+          context "no rules match the option values" do
+            let(:parameters) do
+              {
+                product_id: product.to_param,
+                ovi: [size_large.id]
+              }
+            end
+
+            before { subject }
+
+            it "instantiates a new variant property rule" do
+              expect(assigns(:variant_property_rule)).to_not be_persisted
+            end
+          end
+
+          context "a rule matches the option values" do
+            let(:parameters) do
+              {
+                product_id: product.to_param,
+                ovi: [size_small.id]
+              }
+            end
+
+            before { subject }
+
+            it "assigns the property rule to the only property rule that matches the option values" do
+              expect(assigns(:variant_property_rule)).to eq first_rule
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/controllers/spree/admin/products_controller_spec.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::ProductsController, type: :controller do
+  stub_authorization!
+
+  context "#index" do
+    let(:ability_user) { stub_model(Spree::LegacyUser, has_spree_role?: true) }
+
+    # Regression test for https://github.com/spree/spree/issues/1259
+    it "can find a product by SKU" do
+      product = create(:product, sku: "ABC123")
+      get :index, params: { q: { sku_start: "ABC123" } }
+      expect(assigns[:collection]).not_to be_empty
+      expect(assigns[:collection]).to include(product)
+    end
+
+    # Regression test for https://github.com/spree/spree/issues/1903
+    context 'when soft deleted products exist' do
+      let!(:soft_deleted_product) { create(:product, sku: "ABC123") }
+      before { soft_deleted_product.discard }
+
+      context 'when params[:q][:with_deleted] is not set' do
+        let(:params) { { q: {} } }
+
+        it 'filters out soft-deleted products by default' do
+          get :index, params: params
+          expect(assigns[:collection]).to_not include(soft_deleted_product)
+        end
+      end
+
+      context 'when params[:q][:with_deleted] is set to "true"' do
+        let(:params) { { q: { with_deleted: 'true' } } }
+
+        it 'includes soft-deleted products' do
+          get :index, params: params
+          expect(assigns[:collection]).to include(soft_deleted_product)
+        end
+      end
+    end
+  end
+
+  # regression test for https://github.com/spree/spree/issues/1370
+  context "adding properties to a product" do
+    let!(:product) { create(:product) }
+    specify do
+      put :update, params: { id: product.to_param, product: { product_properties_attributes: { "1" => { property_name: "Foo", value: "bar" } } } }
+      expect(flash[:success]).to eq("Product #{product.name.inspect} has been successfully updated!")
+    end
+  end
+
+  # regression test for https://github.com/solidusio/solidus/issues/2791
+  context "creating a product" do
+    before(:all) do
+      create(:shipping_category)
+    end
+
+    it "creates a product" do
+      post :create, params: {
+             product: {
+               name: "Product #1 - 9632",
+               description: "As seen on TV!",
+               price: 19.99,
+               shipping_category_id: Spree::ShippingCategory.first.id,
+             }
+           }
+      expect(flash[:success]).to eq("Product \"Product #1 - 9632\" has been successfully created!")
+    end
+
+    context "when there is a taxon" do
+      let(:first_taxon) { create(:taxon) }
+
+      it "creates a product with a taxon" do
+        post :create, params: {
+               product: {
+                 name: "Product #1 - 9632",
+                 description: "As seen on TV!",
+                 price: 19.99,
+                 shipping_category_id: Spree::ShippingCategory.first.id,
+                 taxon_ids: first_taxon.id.to_s
+               }
+             }
+        expect(flash[:success]).to eq("Product \"Product #1 - 9632\" has been successfully created!")
+      end
+
+      context "when their are multiple taxons" do
+        let(:second_taxon) { create(:taxon) }
+
+        it "creates a product with multiple taxons" do
+          post :create, params: {
+                 product: {
+                   name: "Product #1 - 9632",
+                   description: "As seen on TV!",
+                   price: 19.99,
+                   shipping_category_id: Spree::ShippingCategory.first.id,
+                   taxon_ids: "#{first_taxon.id}, #{second_taxon.id}"
+                 }
+               }
+          expect(flash[:success]).to eq("Product \"Product #1 - 9632\" has been successfully created!")
+        end
+      end
+    end
+  end
+
+  context "adding taxons to a product" do
+    let(:product) { create(:product) }
+    let(:first_taxon) { create(:taxon) }
+
+    it "adds a single taxon to a product" do
+      put :update, params: { id: product.to_param, product: { taxon_ids: first_taxon.id.to_s } }
+      expect(flash[:success]).to eq("Product #{product.name.inspect} has been successfully updated!")
+    end
+
+    context "when there are mulitple taxons" do
+      let(:second_taxon) { create(:taxon) }
+
+      it "adds multiple taxons to a product" do
+        put :update, params: { id: product.to_param, product: { taxon_ids: "#{first_taxon.id}, #{second_taxon.id}" } }
+        expect(flash[:success]).to eq("Product #{product.name.inspect} has been successfully updated!")
+      end
+    end
+  end
+
+  describe "creating variant property rules" do
+    let(:first_property) { create(:property) }
+    let(:second_property) { create(:property) }
+    let(:option_value) { create(:option_value) }
+    let!(:product) { create(:product, option_types: [option_value.option_type]) }
+    let(:payload) do
+      {
+        id: product.to_param,
+        product: {
+          id: product.id,
+          variant_property_rules_attributes: {
+            "0" => {
+              option_value_ids: option_value.id,
+              values_attributes: {
+                "0" => {
+                  property_name: first_property.name,
+                  value: "First"
+                },
+                "1" => {
+                  property_name: second_property.name,
+                  value: "Second"
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+
+    subject { put :update, params: payload }
+
+    it "creates a variant property rule" do
+      expect { subject }.to change { product.variant_property_rules.count }.by(1)
+    end
+
+    it "creates a variant property rule condition" do
+      expect { subject }.to change { product.variant_property_rule_conditions.count }.by(1)
+    end
+
+    it "creates a variant property rule value for the 'First' value" do
+      subject
+      expect(product.variant_property_rule_values.find_by(value: 'First')).to_not be_nil
+    end
+
+    it "creates a variant property rule value for the 'Second' value" do
+      subject
+      expect(product.variant_property_rule_values.find_by(value: 'Second')).to_not be_nil
+    end
+
+    it "redirects to the product properties page" do
+      subject
+      expect(response).to redirect_to(spree.admin_product_product_properties_path(product, ovi: [option_value.id]))
+    end
+  end
+
+  describe "updating variant property rules" do
+    let(:first_property) { create(:property) }
+    let(:second_property) { create(:property) }
+    let(:option_value) { create(:option_value) }
+    let(:original_option_value) { create(:option_value) }
+    let!(:product) { create(:product, option_types: [option_value.option_type]) }
+    let!(:rule) do
+      create(:variant_property_rule, product: product, option_value: original_option_value)
+    end
+    let(:payload) do
+      {
+        id: product.to_param,
+        product: {
+          id: product.id,
+          variant_property_rules_attributes: {
+            "0" => {
+              id: rule.id,
+              option_value_ids: option_value.id,
+              values_attributes: {
+                "0" => {
+                  property_name: first_property.name,
+                  value: "First Edit"
+                },
+                "1" => {
+                  property_name: second_property.name,
+                  value: "Second Edit"
+                }
+              }
+            }
+          }
+        }
+      }
+    end
+
+    subject { put :update, params: payload }
+
+    it "does not create any new rules" do
+      expect { subject }.to_not change { Spree::VariantPropertyRule.count }
+    end
+
+    it "replaces the rule's condition" do
+      expect { subject }.to change { rule.reload.option_value_ids }.from([original_option_value.id]).to([option_value.id])
+    end
+
+    it "adds two values to the rule" do
+      expect { subject }.to change { rule.values.count }.by(2)
+    end
+
+    it "creates the 'First Edit' value" do
+      subject
+      expect(rule.values.find_by(value: 'First Edit')).to_not be_nil
+    end
+
+    it "creates the 'Second Edit' value" do
+      subject
+      expect(rule.values.find_by(value: 'Second Edit')).to_not be_nil
+    end
+
+    it "redirects to the product properties page" do
+      subject
+      expect(response).to redirect_to(spree.admin_product_product_properties_path(product, ovi: [option_value.id]))
+    end
+  end
+
+  context "cloning a product" do
+    let!(:product) { create(:product) }
+
+    it "duplicates the product" do
+      expect do
+        post :clone, params: { id: product.id }
+      end.to change { Spree::Product.count }.by(1)
+    end
+  end
+
+  # regression test for https://github.com/spree/spree/issues/801
+  context "destroying a product" do
+    let(:product) do
+      product = create(:product)
+      create(:variant, product: product)
+      product
+    end
+
+    it "deletes all the variants (including master) for the product" do
+      delete :destroy, params: { id: product }
+      expect(product.reload.deleted_at).not_to be_nil
+      product.variants_including_master.each do |variant|
+        expect(variant.reload.deleted_at).not_to be_nil
+      end
+    end
+  end
+end

data/spec/controllers/spree/admin/promotion_actions_controller_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::PromotionActionsController, type: :controller do
+  stub_authorization!
+
+  let!(:promotion) { create(:promotion) }
+
+  it "can create a promotion action of a valid type" do
+    post :create, params: { promotion_id: promotion.id, action_type: "Spree::Promotion::Actions::CreateAdjustment" }
+    expect(response).to be_redirect
+    expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
+    expect(promotion.actions.count).to eq(1)
+  end
+
+  it "can not create a promotion action of an invalid type" do
+    post :create, params: { promotion_id: promotion.id, action_type: "Spree::InvalidType" }
+    expect(response).to be_redirect
+    expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
+    expect(promotion.rules.count).to eq(0)
+  end
+end

data/spec/controllers/spree/admin/promotion_codes_controller_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::PromotionCodesController do
+  stub_authorization!
+  render_views
+
+  let!(:promotion) { create(:promotion) }
+  let!(:code1) { create(:promotion_code, promotion: promotion) }
+  let!(:code2) { create(:promotion_code, promotion: promotion) }
+  let!(:code3) { create(:promotion_code, promotion: promotion) }
+
+  it "can create a promotion rule of a valid type" do
+    get :index, params: { promotion_id: promotion.id, format: 'csv' }
+    expect(response).to be_successful
+    parsed = CSV.parse(response.body, headers: true)
+    expect(parsed.entries.map(&:to_h)).to eq([{ "Code" => code1.value }, { "Code" => code2.value }, { "Code" => code3.value }])
+  end
+end

data/spec/controllers/spree/admin/promotion_rules_controller_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::PromotionRulesController, type: :controller do
+  let!(:promotion) { create(:promotion) }
+
+  context "when the user is authorized" do
+    stub_authorization! do |_u|
+      Spree::PermissionSets::PromotionManagement.new(self).activate!
+    end
+
+    it "can create a promotion rule of a valid type" do
+      post :create, params: { promotion_id: promotion.id, promotion_rule: { type: "Spree::Promotion::Rules::Product" } }
+      expect(response).to be_redirect
+      expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
+      expect(promotion.rules.count).to eq(1)
+    end
+
+    it "can not create a promotion rule of an invalid type" do
+      post :create, params: { promotion_id: promotion.id, promotion_rule: { type: "Spree::InvalidType" } }
+      expect(response).to be_redirect
+      expect(response).to redirect_to spree.edit_admin_promotion_path(promotion)
+      expect(promotion.rules.count).to eq(0)
+    end
+  end
+
+  context "when the user is not authorized" do
+    it "sets an error message and redirects the user" do
+      post :create, params: { promotion_id: promotion.id, promotion_rule: { type: "Spree::Promotion::Rules::Product" } }
+
+      expect(flash[:error]).to eq("Authorization Failure")
+      expect(response).to redirect_to('/unauthorized')
+    end
+  end
+end

data/spec/controllers/spree/admin/promotions_controller_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::PromotionsController, type: :controller do
+  stub_authorization!
+
+  let!(:promotion1) { create(:promotion, name: "name1", code: "code1", path: "path1") }
+  let!(:promotion2) { create(:promotion, name: "name2", code: "code2", path: "path2") }
+  let!(:category) { create :promotion_category }
+
+  describe "#show" do
+    it "redirects to edit" do
+      expect(get(:show, params: { id: promotion1.id }))
+        .to redirect_to(action: :edit, id: promotion1.id )
+    end
+  end
+
+  describe "#index" do
+    it "succeeds" do
+      get :index
+      expect(assigns[:promotions]).to match_array [promotion2, promotion1]
+    end
+
+    it "assigns promotion categories" do
+      get :index
+      expect(assigns[:promotion_categories]).to match_array [category]
+    end
+
+    context "search" do
+      it "pages results" do
+        get :index, params: { per_page: '1' }
+        expect(assigns[:promotions]).to eq [promotion2]
+      end
+
+      it "filters by name" do
+        get :index, params: { q: { name_cont: promotion1.name } }
+        expect(assigns[:promotions]).to eq [promotion1]
+      end
+
+      it "filters by code" do
+        get :index, params: { q: { codes_value_cont: promotion1.codes.first.value } }
+        expect(assigns[:promotions]).to eq [promotion1]
+      end
+
+      it "filters by path" do
+        get :index, params: { q: { path_cont: promotion1.path } }
+        expect(assigns[:promotions]).to eq [promotion1]
+      end
+    end
+  end
+
+  describe "#create" do
+    subject { post :create, params: params }
+    let(:params) { { promotion: { name: 'some promo' } } }
+
+    context "it succeeds" do
+      context "with no single code param" do
+        it "creates a promotion" do
+          expect { subject }.to change { Spree::Promotion.count }.by(1)
+        end
+
+        it "sets the flash message" do
+          subject
+          expect(flash[:success]).to eq "Promotion has been successfully created!"
+        end
+
+        it "redirects to promotion edit" do
+          subject
+          expect(response).to redirect_to "http://test.host/admin/promotions/#{assigns(:promotion).id}/edit"
+        end
+
+        it "doesn't create any promotion codes" do
+          expect { subject }.to_not change { Spree::PromotionCode.count }
+        end
+      end
+
+      context "with a single code" do
+        let(:params) { { promotion: { name: 'some promo' }, single_code: "promo" } }
+
+        it "creates a promotion" do
+          expect { subject }.to change { Spree::Promotion.count }.by(1)
+        end
+
+        it "sets the flash message" do
+          subject
+          expect(flash[:success]).to eq "Promotion has been successfully created!"
+        end
+
+        it "redirects to promotion edit" do
+          subject
+          expect(response).to redirect_to "http://test.host/admin/promotions/#{assigns(:promotion).id}/edit"
+        end
+
+        it "creates a promotion code" do
+          expect { subject }.to change { Spree::PromotionCode.count }.by(1)
+          expect(Spree::PromotionCode.last.value).to eq("promo")
+        end
+      end
+    end
+
+    context "it fails" do
+      let(:params) { {} }
+
+      it "does not create a promotion" do
+        expect {
+          subject
+        }.not_to change { Spree::Promotion.count }
+      end
+
+      it "sets the flash error" do
+        subject
+        expect(flash[:error]).to eq "Name can't be blank"
+      end
+
+      it "renders new" do
+        subject
+        expect(response).to render_template :new
+      end
+    end
+  end
+end

data/spec/controllers/spree/admin/refunds_controller_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Spree::Admin::RefundsController do
+  stub_authorization!
+
+  describe "POST create" do
+    context "a Spree::Core::GatewayError is raised" do
+      let(:payment) { create(:payment) }
+
+      subject do
+        post :create,
+          params: {
+          refund: { amount: "50.0", refund_reason_id: "1" },
+          order_id: payment.order_id,
+          payment_id: payment.id
+        }
+      end
+
+      before(:each) do
+        def controller.create
+          raise Spree::Core::GatewayError.new('An error has occurred')
+        end
+      end
+
+      it "sets an error message with the correct text" do
+        subject
+        expect(flash[:error]).to eq 'An error has occurred'
+      end
+
+      it { is_expected.to render_template(:new) }
+    end
+  end
+end