solidus_backend 1.0.2 → 1.0.3

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Spree
+  class GatewayWithPassword < PaymentMethod
+    preference :password, :string, :default => "password"
+  end
+
+  describe Admin::PaymentMethodsController, :type => :controller do
+    stub_authorization!
+
+    let(:payment_method) { GatewayWithPassword.create!(:name => "Bogus", :preferred_password => "haxme") }
+
+    # regression test for #2094
+    it "does not clear password on update" do
+      expect(payment_method.preferred_password).to eq("haxme")
+      spree_put :update, :id => payment_method.id, :payment_method => { :type => payment_method.class.to_s, :preferred_password => "" }
+      expect(response).to redirect_to(spree.edit_admin_payment_method_path(payment_method))
+
+      payment_method.reload
+      expect(payment_method.preferred_password).to eq("haxme")
+    end
+
+    context "tries to save invalid payment" do
+      it "doesn't break, responds nicely" do
+        expect {
+          spree_post :create, :payment_method => { :name => "", :type => "Spree::Gateway::Bogus" }
+        }.not_to raise_error
+      end
+    end
+
+    it "can create a payment method of a valid type" do
+      expect {
+        spree_post :create, :payment_method => { :name => "Test Method", :type => "Spree::Gateway::Bogus" }
+      }.to change(Spree::PaymentMethod, :count).by(1)
+
+      expect(response).to be_redirect
+      expect(response).to redirect_to spree.edit_admin_payment_method_path(assigns(:payment_method))
+    end
+
+    it "can not create a payment method of an invalid type" do
+      expect {
+        spree_post :create, :payment_method => { :name => "Invalid Payment Method", :type => "Spree::InvalidType" }
+      }.to change(Spree::PaymentMethod, :count).by(0)
+
+      expect(response).to be_redirect
+      expect(response).to redirect_to spree.new_admin_payment_method_path
+    end
+  end
+end

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

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+module Spree
+  module Admin
+    describe PaymentsController, :type => :controller do
+      before do
+        allow(controller).to receive_messages :spree_current_user => user
+      end
+
+      let(:user) { create(:admin_user) }
+      let(:order) { create(:order) }
+
+      context "with a valid credit card" do
+        let(:order) { create(:order_with_line_items, :state => "payment") }
+        let(:payment_method) { create(:credit_card_payment_method, :display_on => "back_end") }
+        let(:attributes) do
+          {
+            :order_id => order.number,
+            :card => "new",
+            :payment => {
+              :amount => order.total,
+              :payment_method_id => payment_method.id.to_s,
+              :source_attributes => {
+                :name => "Test User",
+                :number => "4111 1111 1111 1111",
+                :expiry => "09 / #{Time.now.year + 1}",
+                :verification_value => "123"
+              }
+            }
+          }
+        end
+
+        before do
+          spree_post :create, attributes
+        end
+
+        it "should process payment correctly" do
+          expect(order.payments.count).to eq(1)
+          expect(order.payments.last.state).to eq 'checkout'
+          expect(response).to redirect_to(spree.admin_order_payments_path(order))
+          expect(order.reload.state).to eq('confirm')
+        end
+
+        context 'with credit card address fields' do
+          let(:address) { build(:address) }
+
+          let(:attributes) do
+            attrs = super()
+            attrs[:payment][:source_attributes][:address_attributes] = address_attributes
+            attrs
+          end
+
+          let(:address_attributes) do
+            {
+              'firstname' => address.firstname,
+              'lastname' => address.lastname,
+              'address1' => address.address1,
+              'city' => address.city,
+              'country_id' => address.country_id,
+              'state_id' => address.state_id,
+              'zipcode' => address.zipcode,
+              'phone' => address.phone,
+            }
+          end
+
+          it 'associates the address' do
+            expect(order.payments.count).to eq(1)
+            credit_card = order.payments.last.source
+            expect(credit_card.address.attributes).to include(address_attributes)
+          end
+        end
+      end
+
+      # Regression test for #3233
+      context "with a backend payment method" do
+        before do
+          @payment_method = create(:check_payment_method, :display_on => "back_end")
+        end
+
+        it "loads backend payment methods" do
+          spree_get :new, :order_id => order.number
+          expect(response.status).to eq(200)
+          expect(assigns[:payment_methods]).to include(@payment_method)
+        end
+      end
+
+      context "order has billing address" do
+        before do
+          order.bill_address = create(:address)
+          order.save!
+        end
+
+        context "order does not have payments" do
+          it "redirect to new payments page" do
+            spree_get :index, { amount: 100, order_id: order.number }
+            expect(response).to redirect_to(spree.new_admin_order_payment_path(order))
+          end
+        end
+
+        context "order has payments" do
+          before do
+            order.payments << create(:payment, amount: order.total, order: order, state: 'completed')
+          end
+
+          it "shows the payments page" do
+            spree_get :index, { amount: 100, order_id: order.number }
+            expect(response.code).to eq "200"
+          end
+        end
+
+      end
+
+      context "order does not have a billing address" do
+        before do
+          order.bill_address = nil
+          order.save
+        end
+
+        it "should redirect to the customer details page" do
+          spree_get :index, { amount: 100, order_id: order.number }
+          expect(response).to redirect_to(spree.edit_admin_order_customer_path(order))
+        end
+      end
+
+      describe 'fire' do
+        describe 'authorization' do
+          let(:payment) { create(:payment, state: 'checkout') }
+          let(:order) { payment.order }
+
+          context 'the user is authorized' do
+            class CaptureAllowedAbility
+              include CanCan::Ability
+
+              def initialize(user)
+                can :capture, Spree::Payment
+              end
+            end
+
+            before do
+              Spree::Ability.register_ability(CaptureAllowedAbility)
+            end
+
+            it 'allows the action' do
+              expect {
+                spree_post(:fire, id: payment.to_param, e: 'capture', order_id: order.to_param)
+              }.to change { payment.reload.state }.from('checkout').to('completed')
+            end
+          end
+
+          context 'the user is not authorized' do
+            class CaptureNotAllowedAbility
+              include CanCan::Ability
+
+              def initialize(user)
+                cannot :capture, Spree::Payment
+              end
+            end
+
+            before do
+              Spree::Ability.register_ability(CaptureNotAllowedAbility)
+            end
+
+            it 'does not allow the action' do
+              expect {
+                spree_post(:fire, id: payment.to_param, e: 'capture', order_id: order.to_param)
+              }.to_not change { payment.reload.state }
+              expect(flash[:error]).to eq('Authorization Failure')
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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 #1259
+    it "can find a product by SKU" do
+      product = create(:product, :sku => "ABC123")
+      spree_get :index, :q => { :sku_start => "ABC123" }
+      expect(assigns[:collection]).not_to be_empty
+      expect(assigns[:collection]).to include(product)
+    end
+  end
+
+  # regression test for #1370
+  context "adding properties to a product" do
+    let!(:product) { create(:product) }
+    specify do
+      spree_put :update, :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 #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
+      spree_delete :destroy, :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,21 @@
+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
+    spree_post :create, :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
+    spree_post :create, :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,18 @@
+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
+    spree_get :index, promotion_id: promotion.id, format: 'csv'
+    expect(response).to be_success
+    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,21 @@
+require 'spec_helper'
+
+describe Spree::Admin::PromotionRulesController, :type => :controller do
+  stub_authorization!
+
+  let!(:promotion) { create(:promotion) }
+
+  it "can create a promotion rule of a valid type" do
+    spree_post :create, :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
+    spree_post :create, :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

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

@@ -0,0 +1,122 @@
+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 "#index" do
+
+    it "succeeds" do
+      spree_get :index
+      expect(assigns[:promotions]).to match_array [promotion2, promotion1]
+    end
+
+    it "assigns promotion categories" do
+      spree_get :index
+      expect(assigns[:promotion_categories]).to match_array [category]
+    end
+
+    context "search" do
+      it "pages results" do
+        spree_get :index, per_page: '1'
+        expect(assigns[:promotions]).to eq [promotion2]
+      end
+
+      it "filters by name" do
+        spree_get :index, q: {name_cont: promotion1.name}
+        expect(assigns[:promotions]).to eq [promotion1]
+      end
+
+      it "filters by code" do
+        spree_get :index, q: {codes_value_cont: promotion1.codes.first.value }
+        expect(assigns[:promotions]).to eq [promotion1]
+      end
+
+      it "filters by path" do
+        spree_get :index, q: {path_cont: promotion1.path}
+        expect(assigns[:promotions]).to eq [promotion1]
+      end
+    end
+  end
+
+  describe "#create" do
+    subject { spree_post :create, params }
+    let(:params) { {promotion: {name: 'some promo'}} }
+
+    context "it succeeds" 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
+
+      context "with one promo codes" do
+        let(:params) do
+          super().merge(promotion_builder: { base_code: 'abc', number_of_codes: 1 })
+        end
+
+        it "succeeds and creates one code" do
+          expect {
+            expect {
+              subject
+            }.to change { Spree::Promotion.count }.by(1)
+          }.to change { Spree::PromotionCode.count }.by(1)
+
+          expect(assigns(:promotion).codes.first.value).to eq ('abc')
+        end
+      end
+
+      context "with multiple promo codes" do
+        let(:params) do
+          super().merge(promotion_builder: { base_code: 'abc', number_of_codes: 2 })
+        end
+
+        it "succeeds and creates multiple codes" do
+          expect {
+            expect {
+              subject
+            }.to change { Spree::Promotion.count }.by(1)
+          }.to change { Spree::PromotionCode.count }.by(2)
+
+          codes = assigns(:promotion).codes.map(&:value).sort
+          expect(codes.length).to be 2
+          expect(codes[0]).to match(/abc_[a-z]{6}/)
+          expect(codes[1]).to match(/abc_[a-z]{6}/)
+        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