solidus_backend 1.0.7 → 1.1.0.beta1

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

@@ -1,49 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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