spree_backend 3.3.0.rc1 → 3.3.0.rc2

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

@@ -1,137 +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
-  describe '#destroy' do
-    let(:product) { mock_model(Spree::Product) }
-    let(:products) { double(ActiveRecord::Relation) }
-
-    def send_request
-      spree_delete :destroy, id: product, format: :js
-    end
-
-    context 'will successfully destroy product' do
-      before do
-        allow(Spree::Product).to receive(:friendly).and_return(products)
-        allow(products).to receive(:find).with(product.id.to_s).and_return(product)
-        allow(product).to receive(:destroy).and_return(true)
-      end
-
-      describe 'expects to receive' do
-        it { expect(Spree::Product).to receive(:friendly).and_return(products) }
-        it { expect(products).to receive(:find).with(product.id.to_s).and_return(product) }
-        it { expect(product).to receive(:destroy).and_return(true) }
-
-        after { send_request }
-      end
-
-      describe 'assigns' do
-        before { send_request }
-        it { expect(assigns(:product)).to eq(product) }
-      end
-
-      describe 'response' do
-        before { send_request }
-        it { expect(response).to have_http_status(:ok) }
-        it { expect(flash[:success]).to eq(Spree.t('notice_messages.product_deleted')) }
-      end
-    end
-
-    context 'will not successfully destroy product' do
-      before do
-        allow(Spree::Product).to receive(:friendly).and_return(products)
-        allow(products).to receive(:find).with(product.id.to_s).and_return(product)
-        allow(product).to receive(:destroy).and_return(false)
-      end
-
-      describe 'expects to receive' do
-        it { expect(Spree::Product).to receive(:friendly).and_return(products) }
-        it { expect(products).to receive(:find).with(product.id.to_s).and_return(product) }
-        it { expect(product).to receive(:destroy).and_return(false) }
-
-        after { send_request }
-      end
-
-      describe 'assigns' do
-        before { send_request }
-        it { expect(assigns(:product)).to eq(product) }
-      end
-
-      describe 'response' do
-        before { send_request }
-        it { expect(response).to have_http_status(:ok) }
-        it { expect(flash[:error]).to eq(Spree.t('notice_messages.product_not_deleted')) }
-      end
-    end
-  end
-
-  describe '#clone' do
-    let(:product) { create(:custom_product, name: 'MyProduct', sku: 'MySku') }
-    let(:product2) { create(:custom_product, name: 'COPY OF MyProduct', sku: 'COPY OF MySku') }
-    let(:variant) do
-      create(:master_variant, name: 'COPY OF MyProduct', sku: 'COPY OF MySku', created_at: product.created_at - 1.day)
-    end
-
-    def send_request
-      spree_post :clone, id: product, format: :js
-    end
-
-    context 'will successfully clone product' do
-      before do
-        allow(product).to receive(:duplicate).and_return(product2)
-      end
-
-      describe 'response' do
-        before { send_request }
-        it { expect(response).to have_http_status(:found) }
-        it { expect(response).to be_redirect }
-        it { expect(flash[:success]).to eq(Spree.t('notice_messages.product_cloned')) }
-      end
-    end
-
-    context 'will not successfully clone product' do
-      before do
-        variant
-      end
-
-      describe 'response' do
-        before { send_request }
-        it { expect(response).to have_http_status(:found) }
-        it { expect(response).to be_redirect }
-        it { expect(flash[:error]).to eq(Spree.t('notice_messages.product_not_cloned')) }
-      end
-    end
-  end
-
-  context "stock" do
-    let(:product) { create(:product) }
-    it "restricts stock location based on accessible attributes" do
-      expect(Spree::StockLocation).to receive(:accessible_by).and_return([])
-      spree_get :stock, id: product
-    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_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,44 +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 }
-
-  context "#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: {code_cont: promotion1.code}
-        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
-
-end

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

@@ -1,32 +0,0 @@
-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
-        spree_post :create,
-                   refund: { amount: "50.0", refund_reason_id: "1" },
-                   order_id: payment.order.to_param,
-                   payment_id: payment.to_param
-      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 { should render_template(:new) }
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Admin::ReimbursementsController, type: :controller do
-  stub_authorization!
-
-  let!(:default_refund_reason) do
-    Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false)
-  end
-
-  describe '#create' do
-    let(:customer_return)  { create(:customer_return, line_items_count: 1) }
-    let(:order) { customer_return.order }
-    let(:return_item) { customer_return.return_items.first }
-    let(:payment) { order.payments.first }
-
-    subject do
-      spree_post :create, order_id: order.to_param, build_from_customer_return_id: customer_return.id
-    end
-
-    it 'creates the reimbursement' do
-      expect { subject }.to change { order.reimbursements.count }.by(1)
-      expect(assigns(:reimbursement).return_items.to_a).to eq customer_return.return_items.to_a
-    end
-
-    it 'redirects to the edit page' do
-      subject
-      expect(response).to redirect_to(spree.edit_admin_order_reimbursement_path(order, assigns(:reimbursement)))
-    end
-  end
-
-  describe "#perform" do
-    let(:reimbursement) { create(:reimbursement) }
-    let(:customer_return) { reimbursement.customer_return }
-    let(:order) { reimbursement.order }
-    let(:return_items) { reimbursement.return_items }
-    let(:payment) { order.payments.first }
-
-    subject do
-      spree_post :perform, order_id: order.to_param, id: reimbursement.to_param
-    end
-
-    it 'redirects to customer return page' do
-      subject
-      expect(response).to redirect_to spree.admin_order_reimbursement_path(order, reimbursement)
-    end
-
-    it 'performs the reimbursement' do
-      expect {
-        subject
-      }.to change { payment.refunds.count }.by(1)
-      expect(payment.refunds.last.amount).to be > 0
-      expect(payment.refunds.last.amount).to eq return_items.to_a.sum(&:total)
-    end
-
-    context "a Spree::Core::GatewayError is raised" do
-      before(:each) do
-        def controller.perform
-          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 'redirects to the edit page' do
-        subject
-        redirect_path = spree.edit_admin_order_reimbursement_path(order, assigns(:reimbursement))
-        expect(response).to redirect_to(redirect_path)
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Admin::ReportsController, type: :controller do
-  stub_authorization!
-
-  describe 'ReportsController.available_reports' do
-    it 'should contain sales_total' do
-      expect(Spree::Admin::ReportsController.available_reports.keys.include?(:sales_total)).to be true
-    end
-
-    it 'should have the proper sales total report description' do
-      expect(Spree::Admin::ReportsController.available_reports[:sales_total][:description]).to eql('Sales Total For All Orders')
-    end
-
-  end
-
-  describe 'ReportsController.add_available_report!' do
-    context 'when adding the report name' do
-      it 'should contain the report' do
-        Spree::Admin::ReportsController.add_available_report!(:some_report)
-        expect(Spree::Admin::ReportsController.available_reports.keys.include?(:some_report)).to be true
-      end
-    end
-  end
-
-  describe 'GET index' do
-    it 'should be ok' do
-      spree_get :index
-      expect(response).to be_ok
-    end
-  end
-
-  it 'should respond to model_class as Spree::AdminReportsController' do
-    expect(controller.send(:model_class)).to eql(Spree::Admin::ReportsController)
-  end
-
-  after(:each) do
-    Spree::Admin::ReportsController.available_reports.delete_if do |key, value|
-      key != :sales_total
-    end
-  end
-end

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

@@ -1,252 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module Admin
-    class WidgetsController < Spree::Admin::ResourceController
-      prepend_view_path('spec/test_views')
-
-      def model_class
-        Widget
-      end
-    end
-  end
-end
-
-describe Spree::Admin::WidgetsController, type: :controller do
-  stub_authorization!
-
-  after(:all) do
-    # Spree::Core::Engine.routes.reload_routes!
-    Rails.application.reload_routes!
-  end
-
-  with_model 'Widget', scope: :all do
-    table do |t|
-      t.string :name
-      t.integer :position
-      t.timestamps null: false
-    end
-
-    model do
-      acts_as_list
-      validates :name, presence: true
-    end
-  end
-
-  before do
-    Spree::Core::Engine.routes.draw do
-      namespace :admin do
-        resources :widgets do
-          post :update_positions, on: :member
-        end
-      end
-    end
-    stub_const('Spree::Widget', Widget)
-  end
-
-  describe '#new' do
-    subject do
-      spree_get :new
-    end
-
-    it 'succeeds' do
-      subject
-      expect(response).to be_success
-    end
-  end
-
-  describe '#edit' do
-    let(:widget) { Widget.create!(name: 'a widget') }
-
-    subject do
-      spree_get :edit, id: widget.to_param
-    end
-
-    it 'succeeds' do
-      subject
-      expect(response).to be_success
-    end
-  end
-
-  describe '#create' do
-    let(:params) do
-      {widget: {name: 'a widget'}}
-    end
-
-    subject { spree_post :create, params }
-
-    it 'creates the resource' do
-      expect { subject }.to change { Widget.count }.by(1)
-    end
-
-    context 'without any parameters' do
-      let(:params) { {} }
-
-      before do
-        allow_any_instance_of(Widget).to receive(:name).and_return('some name')
-      end
-
-      it 'creates the resource' do
-        expect { subject }.to change { Widget.count }.by(1)
-      end
-    end
-  end
-
-  describe '#update' do
-    let(:widget) { Widget.create!(name: 'a widget') }
-
-    let(:params) do
-      {
-        id: widget.to_param,
-        widget: {name: 'widget renamed'},
-      }
-    end
-
-    subject { spree_put :update, params }
-
-    it 'updates the resource' do
-      expect { subject }.to change { widget.reload.name }.from('a widget').to('widget renamed')
-    end
-  end
-
-  describe '#destroy' do
-    let!(:widget) { Widget.create!(name: 'a widget') }
-    let(:params) { {id: widget.id} }
-
-    subject {
-      spree_delete :destroy, params
-    }
-
-    it 'destroys the resource' do
-      expect { subject }.to change { Widget.count }.from(1).to(0)
-    end
-  end
-
-  describe '#update_positions' do
-    let(:widget_1) { Widget.create!(name: 'widget 1', position: 1) }
-    let(:widget_2) { Widget.create!(name: 'widget 2', position: 2) }
-
-    subject do
-      spree_post :update_positions, id: widget_1.to_param,
-        positions: { widget_1.id => '2', widget_2.id => '1' }, format: 'js'
-    end
-
-    it 'updates the position of widget 1' do
-      expect { subject }.to change { widget_1.reload.position }.from(1).to(2)
-    end
-
-    it 'updates the position of widget 2' do
-      expect { subject }.to change { widget_2.reload.position }.from(2).to(1)
-    end
-
-    it 'touches updated_at' do
-      Timecop.scale(3600) do
-        expect { subject }.to change { widget_1.reload.updated_at }
-      end
-    end
-  end
-end
-
-module Spree
-  module Submodule
-    class Post < Spree::Base
-    end
-  end
-  module Admin
-    module Submodule
-      class PostsController < Spree::Admin::ResourceController
-        prepend_view_path('spec/test_views')
-
-        def model_class
-          Spree::Submodule::Post
-        end
-      end
-    end
-  end
-end
-
-describe Spree::Admin::Submodule::PostsController, type: :controller do
-  stub_authorization!
-
-  after(:all) do
-    # Spree::Core::Engine.routes.reload_routes!
-    Rails.application.reload_routes!
-  end
-
-  with_table 'spree_posts', scope: :all do |t|
-    t.string :name
-    t.integer :position
-    t.timestamps null: false
-  end
-
-  before do
-    Spree::Core::Engine.routes.draw do
-      namespace :admin do
-        namespace :submodule do
-          resources :posts
-        end
-      end
-    end
-  end
-
-  describe '#new' do
-    subject do
-      spree_get :new
-    end
-
-    it 'succeeds' do
-      subject
-      expect(response).to be_success
-    end
-  end
-
-  describe '#edit' do
-    let(:submodule_post) { Spree::Submodule::Post.create!(name: 'a post') }
-
-    subject do
-      spree_get :edit, id: submodule_post.to_param
-    end
-
-    it 'succeeds' do
-      subject
-      expect(response).to be_success
-    end
-  end
-
-  describe '#create' do
-    let(:params) do
-      { submodule_post: { name: 'a post' } }
-    end
-
-    subject { spree_post :create, params }
-
-    it 'creates the resource' do
-      expect { subject }.to change { Spree::Submodule::Post.count }.by(1)
-    end
-  end
-
-  describe '#update' do
-    let(:post) { Spree::Submodule::Post.create!(name: 'a post') }
-
-    let(:params) do
-      { id: post.to_param, submodule_post: { name: 'post renamed' } }
-    end
-
-    subject { spree_put :update, params }
-
-    it 'updates the resource' do
-      expect { subject }.to change { post.reload.name }.from('a post').to('post renamed')
-    end
-  end
-
-  describe '#destroy' do
-    let!(:post) { Spree::Submodule::Post.create!(name: 'a post') }
-    let(:params) { { id: post.id } }
-
-    subject { spree_delete :destroy, params }
-
-    it 'destroys the resource' do
-      expect { subject }.to change { Spree::Submodule::Post.count }.from(1).to(0)
-    end
-  end
-end