solidus_backend 1.0.7 → 1.1.0.beta1

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_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

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

@@ -1,75 +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 }
-    before { return_item.receive! }
-
-    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,134 +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 sales_total' do
-
-    let!(:order_complete_start_of_month) { create(:completed_order_with_totals) }
-    let!(:order_complete_mid_month) { create(:completed_order_with_totals) }
-    let!(:order_non_complete) { create(:order, completed_at: nil) }
-
-    before do
-      # can't set completed_at during factory creation
-      order_complete_start_of_month.completed_at = Time.zone.now.beginning_of_month + 1.minute
-      order_complete_start_of_month.save!
-
-      order_complete_mid_month.completed_at = Time.zone.now.beginning_of_month + 15.days
-      order_complete_mid_month.save!
-    end
-
-    subject { spree_get :sales_total, params }
-
-    shared_examples 'sales total report' do
-      it 'should respond with success' do
-        expect(response).to be_success
-      end
-
-      it 'should set search to be a ransack search' do
-        subject
-        expect(assigns(:search)).to be_a Ransack::Search
-      end
-
-      it 'should set orders correctly for date parameters' do
-        subject
-        expect(assigns(:orders)).to eq expected_returned_orders
-      end
-
-      it 'does not include non-complete orders' do
-        subject
-        expect(assigns(:orders)).to_not include(order_non_complete)
-      end
-
-      it 'should correctly set the totals hash' do
-        subject
-        expect(assigns(:totals)).to eq expected_totals
-      end
-    end
-
-    context 'when no dates are specified' do
-      let(:params) { { } }
-
-      it_behaves_like 'sales total report' do
-        let(:expected_returned_orders) { [order_complete_mid_month, order_complete_start_of_month] }
-        let(:expected_totals) {
-          {
-            'USD' => {
-              item_total: Money.new(2000, 'USD'),
-              adjustment_total: Money.new(0, 'USD'),
-              sales_total: Money.new(22000, 'USD')
-            }
-          }
-        }
-      end
-    end
-
-    context 'when params has a completed_at_gt' do
-      let(:params) { { q: { completed_at_gt: Time.zone.now.beginning_of_month + 1.day } } }
-
-      it_behaves_like 'sales total report' do
-        let(:expected_returned_orders) { [order_complete_mid_month] }
-        let(:expected_totals) {
-          {
-            'USD' => {
-              item_total: Money.new(1000, 'USD'),
-              adjustment_total: Money.new(0, 'USD'),
-              sales_total: Money.new(11000, 'USD')
-            }
-          }
-        }
-      end
-    end
-
-    context 'when params has a compeleted_at_lt' do
-      let(:params) { { q: { completed_at_lt: Time.zone.now.beginning_of_month } } }
-
-      it_behaves_like 'sales total report' do
-        let(:expected_returned_orders) { [order_complete_start_of_month] }
-        let(:expected_totals) {
-          {
-            'USD' => {
-              item_total: Money.new(1000, 'USD'),
-              adjustment_total: Money.new(0, 'USD'),
-              sales_total: Money.new(11000, 'USD')
-            }
-          }
-        }
-      end
-    end
-  end
-
-  describe 'GET index' do
-    it 'should be ok' do
-      spree_get :index
-      expect(response).to be_ok
-    end
-  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,166 +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, :truncation => true do
-  stub_authorization!
-
-  after(:all) do
-    # Spree::Core::Engine.routes.reload_routes!
-    Rails.application.reload_routes!
-  end
-
-  with_model 'Widget' 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
-  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 'failure' do
-      let(:params) do
-        {widget: {name: ''}} # blank name generates an error
-      end
-
-      it 'sets a flash error' do
-        subject
-        expect(flash[:error]).to eq assigns(:widget).errors.full_messages.join(', ')
-      end
-    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
-
-    context 'failure' do
-      let(:params) do
-        {
-          id: widget.to_param,
-          widget: {name: ''}, # a blank name will trigger a validation error
-        }
-      end
-
-      it 'sets a flash error' do
-        subject
-        expect(flash[:error]).to eq assigns(:widget).errors.full_messages.join(', ')
-      end
-    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
-  end
-end

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

@@ -1,226 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Admin::ReturnAuthorizationsController, :type => :controller do
-  stub_authorization!
-
-  # Regression test for #1370 #3
-  let!(:order) { create(:shipped_order, line_items_count: 3) }
-  let!(:return_reason) { create(:return_reason) }
-  let(:inventory_unit_1) { order.inventory_units.order('id asc')[0] }
-  let(:inventory_unit_2) { order.inventory_units.order('id asc')[1] }
-  let(:inventory_unit_3) { order.inventory_units.order('id asc')[2] }
-
-  describe "#load_return_reasons" do
-    let!(:inactive_rma_reason) { create(:return_reason, active: false) }
-
-    context "a return item in the return authorization has an associated inactive reason" do
-      let!(:other_inactive_rma_reason) { create(:return_reason, active: false) }
-      let(:return_item) { create(:return_item, return_reason: inactive_rma_reason) }
-      let(:return_authorization) { return_item.return_authorization }
-
-      it "loads all the active rma reasons" do
-        spree_get :edit, id: return_authorization.to_param, order_id: return_authorization.order.to_param
-        expect(assigns(:reasons)).to include(return_reason)
-        expect(assigns(:reasons)).to include(inactive_rma_reason)
-        expect(assigns(:reasons)).not_to include(other_inactive_rma_reason)
-      end
-    end
-
-    context "return authorization has an associated active reason" do
-      let(:return_authorization) { create(:return_authorization, reason: return_reason) }
-
-      it "loads all the active rma reasons" do
-        spree_get :edit, id: return_authorization.to_param, order_id: return_authorization.order.to_param
-        expect(assigns(:reasons)).to eq [return_reason]
-      end
-    end
-
-    context "return authorization doesn't have an associated reason" do
-      it "loads all the active rma reasons" do
-        spree_get :new, order_id: order.to_param
-        expect(assigns(:reasons)).to eq [return_reason]
-      end
-    end
-  end
-
-  describe "#load_return_items" do
-    shared_context 'without existing return items' do
-      context 'without existing return items' do
-        it 'has 3 new @form_return_items' do
-          subject
-          expect(assigns(:form_return_items).size).to eq 3
-          expect(assigns(:form_return_items).select(&:new_record?).size).to eq 3
-        end
-      end
-    end
-
-    shared_context 'with existing return items' do
-      context 'with existing return items' do
-        let!(:return_item_1) { create(:return_item, inventory_unit: inventory_unit_1, return_authorization: return_authorization) }
-
-        it 'has 1 existing return item and 2 new return items' do
-          subject
-          expect(assigns(:form_return_items).size).to eq 3
-          expect(assigns(:form_return_items).select(&:persisted?)).to eq [return_item_1]
-          expect(assigns(:form_return_items).select(&:new_record?).size).to eq 2
-        end
-      end
-    end
-
-    context '#new' do
-      subject { spree_get :new, order_id: order.to_param }
-
-      include_context 'without existing return items'
-    end
-
-    context '#edit' do
-      subject do
-        spree_get :edit, {
-          id: return_authorization.to_param,
-          order_id: order.to_param,
-        }
-      end
-
-      let(:return_authorization) { create(:return_authorization, order: order) }
-
-      include_context 'without existing return items'
-      include_context 'with existing return items'
-    end
-
-    context '#create failed' do
-      subject do
-        spree_post :create, {
-          return_authorization: {stock_location_id: nil}, # return authorization requires valid stock location, so this will fail
-          order_id: order.to_param,
-        }
-      end
-
-      include_context 'without existing return items'
-    end
-
-    context '#update failed' do
-      subject do
-        spree_put :update, {
-          return_authorization: {stock_location_id: nil}, # return authorization requires valid stock location, so this will fail
-          id: return_authorization.to_param,
-          order_id: order.to_param,
-        }
-      end
-
-      let(:return_authorization) { create(:return_authorization, order: order) }
-
-      include_context 'without existing return items'
-      include_context 'with existing return items'
-    end
-  end
-
-  describe "#load_reimbursement_types" do
-    let(:order)                             { create(:order) }
-    let!(:inactive_reimbursement_type)      { create(:reimbursement_type, active: false) }
-    let!(:first_active_reimbursement_type)  { create(:reimbursement_type) }
-    let!(:second_active_reimbursement_type) { create(:reimbursement_type) }
-
-    before do
-      spree_get :new, order_id: order.to_param
-    end
-
-    it "loads all the active reimbursement types" do
-      expect(assigns(:reimbursement_types)).to include(first_active_reimbursement_type)
-      expect(assigns(:reimbursement_types)).to include(second_active_reimbursement_type)
-      expect(assigns(:reimbursement_types)).not_to include(inactive_reimbursement_type)
-    end
-  end
-
-  context '#create' do
-    let(:stock_location) { create(:stock_location) }
-
-    subject { spree_post :create, params }
-
-    let(:params) do
-      {
-        order_id: order.to_param,
-        return_authorization: return_authorization_params,
-      }
-    end
-
-    let(:return_authorization_params) do
-      {
-        memo: "",
-        stock_location_id: stock_location.id,
-        return_reason_id: return_reason.id,
-      }
-    end
-
-    it "can create a return authorization" do
-      subject
-      expect(response).to redirect_to spree.admin_order_return_authorizations_path(order)
-    end
-  end
-
-  context '#update' do
-    let(:return_authorization) { create(:return_authorization, order: order) }
-
-    let(:params) do
-      {
-        id: return_authorization.to_param,
-        order_id: order.to_param,
-        return_authorization: return_authorization_params,
-      }
-    end
-    let(:return_authorization_params) do
-      {
-        memo: "",
-        return_items_attributes: return_items_params,
-      }
-    end
-
-    subject { spree_put :update, params }
-
-    context "adding an item" do
-      let(:return_items_params) do
-        {
-          '0' => {inventory_unit_id: inventory_unit_1.to_param}
-        }
-      end
-
-      context 'without existing items' do
-        it 'creates a new item' do
-          expect { subject }.to change { Spree::ReturnItem.count }.by(1)
-        end
-      end
-
-      context 'with existing completed items' do
-        let!(:completed_return_item) do
-          create(:return_item, {
-            return_authorization: return_authorization,
-            inventory_unit: inventory_unit_1,
-            reception_status: 'received',
-          })
-        end
-
-        it 'does not create new items' do
-          expect { subject }.to_not change { Spree::ReturnItem.count }
-          expect(assigns[:return_authorization].errors['return_items.inventory_unit']).to eq ["#{inventory_unit_1.id} has already been taken by return item #{completed_return_item.id}"]
-        end
-      end
-    end
-
-    context "removing an item" do
-      let!(:return_item) do
-        create(:return_item, return_authorization: return_authorization, inventory_unit: inventory_unit_1)
-      end
-
-      let(:return_items_params) do
-        {
-          '0' => {id: return_item.to_param, _destroy: '1'}
-        }
-      end
-
-      context 'with existing items' do
-        it 'removes the item' do
-          expect { subject }.to change { Spree::ReturnItem.count }.by(-1)
-        end
-      end
-    end
-  end
-end