solidus_backend 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a2e1ff201da7a8004b89716041c342dc94fc6ba6
-  data.tar.gz: 79c76e8007269a1f5f784dea5ceba07cb88acd02
+  metadata.gz: 953dc27b089e11d656f2a2d2bd2ecbed6232acd6
+  data.tar.gz: 2b80af790e51a39469baa78a96684a8d1c3d3163
 SHA512:
-  metadata.gz: 14d7fd267a84d562560977371fe0fec7698fa1e39a5ba07c26245ffaef765e125d518ee4d373d050b73ccae2f89fe6e67ab34443b56bd963d1ee97f42cbf10b7
-  data.tar.gz: 2e93212d4a411dd2b090a2391f0624f9257c82329b9996aede555c39530bf116c81c625ddad4a67d53607b6604691bba45b34b85ab25859201e5ee27e17e3136
+  metadata.gz: c1d88a6450be2bad9a8fd5b9cfb9eebb7bbdd881a0f63720f3fc644bfedb7d99b33a35a9935ee146a4e999e210ceaf505db20b850f08431319509b153f78ebfd
+  data.tar.gz: ab0f0ef232e9f674f1d145a9f7d9d58f9b04b5dc6ff437f7c38a615bbf1177e9476722a69a590e9efc939e5a90f2913753cad39ae528239ac6ac76b2bf5af21f

data/Gemfile

@@ -0,0 +1,6 @@
+eval(File.read(File.dirname(__FILE__) + '/../common_spree_dependencies.rb'))
+
+gem 'solidus_core', :path => '../core'
+gem 'solidus_api', :path => '../api'
+
+gemspec

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree/backend'
+  Rake::Task['common:test_app'].invoke
+end

data/script/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/spree/backend/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'
+

data/solidus_backend.gemspec

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+version = File.read(File.expand_path("../../SOLIDUS_VERSION", __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'solidus_backend'
+  s.version     = version
+  s.summary     = 'Admin interface for the Solidus e-commerce framework.'
+  s.description = s.summary
+
+  s.required_ruby_version = '>= 2.1.0'
+  s.author      = 'Solidus Team'
+  s.email       = 'contact@solidus.io'
+  s.homepage    = 'http://solidus.io'
+  s.rubyforge_project = 'solidus_backend'
+
+  s.files        = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+  s.requirements << 'none'
+
+  s.add_dependency 'solidus_api', version
+  s.add_dependency 'solidus_core', version
+
+  s.add_dependency 'bourbon'
+  s.add_dependency 'jquery-rails'
+  s.add_dependency 'jquery-ui-rails', '~> 5.0.0'
+  s.add_dependency 'select2-rails',   '3.5.9.1' # 3.5.9.2 breaks forms
+
+  s.add_dependency 'handlebars_assets'
+end

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

@@ -0,0 +1,24 @@
+# Spree's rpsec controller tests get the Spree::ControllerHacks
+# we don't need those for the anonymous controller here, so
+# we call process directly instead of get
+require 'spec_helper'
+
+describe Spree::Admin::BaseController, :type => :controller do
+  controller(Spree::Admin::BaseController) do
+    def index
+      authorize! :update, Spree::Order
+      render :text => 'test'
+    end
+  end
+
+  context "unauthorized request" do
+    before do
+      allow_any_instance_of(Spree::Admin::BaseController).to receive(:spree_current_user).and_return(nil)
+    end
+
+    it "redirects to unauthorized" do
+      get :index
+      expect(response).to redirect_to '/unauthorized'
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Spree::Admin::CancellationsController do
+  stub_authorization!
+
+  describe "#index" do
+    subject { spree_get :index, order_id: order.number }
+
+    let(:order) { create(:order_ready_to_ship, line_items_count: 1)}
+
+    context "for an order with inventory" do
+      render_views
+
+      it "succeeds" do
+        expect(response).to be_ok
+      end
+    end
+  end
+
+  describe "#cancel" do
+    subject { spree_post :short_ship, order_id: order.number, inventory_unit_ids: inventory_units.map(&:id) }
+
+    let(:order) { order = create(:order_ready_to_ship, :number => "R100", :state => "complete", line_items_count: 1) }
+    let(:referer) { "order_admin_page" }
+
+    context "no inventory unit ids are provided" do
+      subject { spree_post :short_ship, order_id: order.number }
+
+      it "redirects back" do
+        subject
+        expect(response).to redirect_to(spree.admin_order_cancellations_path(order))
+      end
+
+      it "sets an error message" do
+        subject
+        expect(flash[:error]).to eq Spree.t(:no_inventory_selected)
+      end
+    end
+
+    context "unable to find all the inventory" do
+      let(:inventory_units) { [Spree::InventoryUnit.new(id: -1)] }
+
+      it "redirects back" do
+        subject
+        expect(response).to redirect_to(spree.admin_order_cancellations_path(order))
+      end
+
+      it "sets an error message" do
+        subject
+        expect(flash[:error]).to eq Spree.t(:unable_to_find_all_inventory_units)
+      end
+    end
+
+    context "successfully cancels inventory" do
+      let(:inventory_units) { order.inventory_units.not_canceled }
+
+      it "redirects to admin order edit" do
+        subject
+        expect(response).to redirect_to(spree.edit_admin_order_path(order))
+      end
+
+      it "sets an success message" do
+        subject
+        expect(flash[:success]).to eq Spree.t(:inventory_canceled)
+      end
+
+      it "creates a unit cancel" do
+        expect { subject }.to change { Spree::UnitCancel.count }.by(1)
+      end
+
+      it "cancels the inventory" do
+        subject
+        expect(order.inventory_units.map(&:state).uniq).to match_array(['canceled'])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+require 'spec_helper'
+
+module Spree
+  module Admin
+    describe CustomerReturnsController, :type => :controller do
+      stub_authorization!
+
+      describe "#index" do
+        let(:order)           { customer_return.order }
+        let(:customer_return) { create(:customer_return) }
+
+        subject do
+          spree_get :index, { order_id: customer_return.order.to_param }
+        end
+
+        before { subject }
+
+        it "loads the order" do
+          expect(assigns(:order)).to eq order
+        end
+
+        it "loads the customer return" do
+          expect(assigns(:customer_returns)).to include(customer_return)
+        end
+      end
+
+      describe "#new" do
+        let(:order) { create(:shipped_order, line_items_count: 1) }
+        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) }
+
+        subject do
+          spree_get :new, { order_id: order.to_param }
+        end
+
+        it "loads the order" do
+          subject
+          expect(assigns(:order)).to eq order
+        end
+
+        it "builds a new customer return" do
+          subject
+          expect(assigns(:customer_return)).to_not be_persisted
+        end
+
+        context "with previous customer return" do
+          let(:return_reason_1) { create(:return_reason) }
+          let(:return_reason_2) { create(:return_reason) }
+          let(:return_reason_3) { create(:return_reason) }
+          let!(:inactive_rma_reason) { create(:return_reason, active: false) }
+
+
+          let(:order) { create(:shipped_order, line_items_count: 4) }
+          let(:rma) { create(:return_authorization, order: order, reason: return_reason_1) }
+
+          let!(:rma_return_item) { create(:return_item, return_authorization: rma, inventory_unit: order.inventory_units.first, return_reason: return_reason_2) }
+          let!(:customer_return_return_item) { create(:return_item, return_authorization: nil, inventory_unit: order.inventory_units.last, return_reason: return_reason_3) }
+
+          context "all return items are associated with a customer return" do
+            let!(:previous_customer_return) { create(:customer_return_without_return_items, return_items: [rma_return_item, customer_return_return_item]) }
+
+            before { subject }
+
+            it "loads the possible return items" do
+              total_inventory_count = 4
+              rma_return_items_count = 1
+              customer_return_return_items_count = 1
+              expect(assigns(:new_return_items).length).to eq (total_inventory_count - rma_return_items_count - customer_return_return_items_count)
+            end
+
+            it "builds new return items" do
+              expect(assigns(:new_return_items).all? { |return_item| !return_item.persisted? }).to eq true
+            end
+
+            it "does not have any rma return items" do
+              expect(assigns(:rma_return_items)).to eq []
+            end
+
+            it "loads the correct return authorization reasons" do
+              expect(assigns(:reasons)).to match_array([return_reason_1, return_reason_2, return_reason_3])
+            end
+          end
+
+          context "there is a return item associated with an rma but not a customer return" do
+            let!(:previous_customer_return) { create(:customer_return_without_return_items, return_items: [customer_return_return_item]) }
+
+            before do
+              subject
+            end
+
+            it "loads the possible return items" do
+              rma_return_item_count = rma.return_items.count
+              total_unit_count = order.inventory_units.count
+              customer_returned_count =  previous_customer_return.return_items.count
+              expected_total = total_unit_count - customer_returned_count - rma_return_item_count
+              expect(assigns(:new_return_items).length).to eq expected_total
+            end
+
+            it "builds new return items" do
+              expect(assigns(:new_return_items).all? { |return_item| !return_item.persisted? }).to eq true
+            end
+
+            it "loads the persisted rma return items" do
+              expect(assigns(:rma_return_items).all? { |return_item| return_item.persisted? }).to eq true
+            end
+
+            it "has one rma return item" do
+              expect(assigns(:rma_return_items)).to include(rma_return_item)
+            end
+
+            it "loads the correct return authorization reasons" do
+              expect(assigns(:reasons)).to match_array([return_reason_1, return_reason_2, return_reason_3])
+            end
+          end
+        end
+      end
+
+      describe "#edit" do
+        let(:order)           { customer_return.order }
+        let(:customer_return) { create(:customer_return, line_items_count: 3) }
+
+        let!(:inactive_rma_reason) { create(:return_reason, active: false) }
+
+        let!(:accepted_return_item)            { customer_return.return_items.order('id').first.tap(&:accept!) }
+        let!(:rejected_return_item)            { customer_return.return_items.order('id').second.tap(&:reject!)}
+        let!(:manual_intervention_return_item) { customer_return.return_items.order('id').third.tap(&:require_manual_intervention!) }
+
+        subject do
+          spree_get :edit, { order_id: order.to_param, id: customer_return.to_param }
+        end
+
+        it "loads the order" do
+          subject
+          expect(assigns(:order)).to eq order
+        end
+
+        it "loads the customer return" do
+          subject
+          expect(assigns(:customer_return)).to eq customer_return
+        end
+
+        it "loads the accepted return items" do
+          subject
+          expect(assigns(:accepted_return_items)).to eq [accepted_return_item]
+        end
+
+        it "loads the rejected return items" do
+          subject
+          expect(assigns(:rejected_return_items)).to eq [rejected_return_item]
+        end
+
+        it "loads the return items that require manual intervention" do
+          subject
+          expect(assigns(:manual_intervention_return_items)).to eq [manual_intervention_return_item]
+        end
+
+        it "loads the return items that are still pending" do
+          subject
+          expect(assigns(:pending_return_items)).to eq []
+        end
+
+        it "loads the reimbursements that are still pending" do
+          subject
+          expect(assigns(:pending_reimbursements)).to eq []
+        end
+
+        it "loads the correct return authorization reasons" do
+          subject
+          expect(assigns(:reasons)).to match(Spree::ReturnReason.active)
+        end
+
+        context "a return item has an inactive return authorization reason" do
+          before(:each) do
+            accepted_return_item.update_attributes(return_reason_id: inactive_rma_reason.id)
+          end
+
+          it "includes the inactive return authorization reason" do
+            subject
+            expect(assigns(:reasons)).to match(Spree::ReturnReason.active + [inactive_rma_reason])
+          end
+        end
+      end
+
+      describe "#create" do
+        let(:order) { create(:shipped_order, line_items_count: 1) }
+        let(:reception_status_event) { 'receive' }
+        let(:stock_location_id) { order.shipments.last.stock_location.id }
+        let(:customer_return_params) do
+          {
+            order_id: order.to_param,
+            customer_return: {
+              stock_location_id: stock_location_id,
+              return_items_attributes: {
+                "0" => {
+                  returned: "1",
+                  "pre_tax_amount"=>"15.99",
+                  inventory_unit_id: order.inventory_units.shipped.last.id,
+                  reception_status_event: reception_status_event
+                }
+              }
+            }
+          }
+        end
+
+        subject { spree_post :create, customer_return_params }
+
+        it { expect { subject }.to change { Spree::CustomerReturn.count }.by(1) }
+        it do
+          subject
+          expect(response).to redirect_to spree.edit_admin_order_customer_return_path(order, id: Spree::CustomerReturn.last.id)
+        end
+
+        it 'executes the reception status event on the return items' do
+          subject
+          customer_return = Spree::CustomerReturn.last
+          expect(customer_return.return_items.map(&:reception_status).uniq).to eq ['received']
+        end
+
+        context "missing stock location" do
+          let(:stock_location_id) { '' }
+          it { expect{ subject }.to_not change { Spree::CustomerReturn.count } }
+          it { subject; expect(response).to render_template(:new) }
+        end
+
+        context "missing reception status event" do
+          let(:reception_status_event) { '' }
+          it { expect{ subject }.to_not change { Spree::CustomerReturn.count } }
+          it { subject; expect(response).to redirect_to spree.new_admin_order_customer_return_path(order) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Spree::Admin::GeneralSettingsController, type: :controller do
+  let(:user) { create(:user) }
+
+  before do
+    allow(controller).to receive_messages :spree_current_user => user
+    user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+  end
+
+  describe '#clear_cache' do
+    subject { spree_post :clear_cache }
+
+    shared_examples 'a HTTP 204 response' do
+      it 'grant access to users with an admin role' do
+        subject
+        expect(response.status).to eq(204)
+      end
+    end
+
+    context 'when no callback' do
+      it_behaves_like 'a HTTP 204 response'
+    end
+
+    context 'when callback implemented' do
+      Spree::Admin::GeneralSettingsController.class_eval do
+        custom_callback(:clear_cache).after :foo
+
+        def foo
+          # Make a call to Akamai, CloudFlare, etc invalidation....
+        end
+      end
+
+      before do
+        expect(controller).to receive(:foo).once
+      end
+
+      it_behaves_like 'a HTTP 204 response'
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+# This test exists in this file because in the standard admin/products_controller spec
+# There is the stub_authorization call. This call is not triggered for this test because
+# the load_resource filter in Spree::Admin::ResourceController is prepended to the filter chain
+# this means this call is triggered before the authorize_admin call and in this case
+# the load_resource filter halts the request meaning authorize_admin is not called at all.
+describe Spree::Admin::ProductsController, :type => :controller do
+  stub_authorization!
+
+  # Regression test for GH #538
+  it "cannot find a non-existent product" do
+    spree_get :edit, :id => "non-existent-product"
+    expect(response).to redirect_to(spree.admin_products_path)
+    expect(flash[:error]).to eql("Product is not found")
+  end
+end
+
+

data/spec/controllers/spree/admin/orders/customer_details_controller_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+require "cancan"
+require "spree/testing_support/bar_ability"
+
+describe Spree::Admin::Orders::CustomerDetailsController, type: :controller do
+
+  context "with authorization" do
+    stub_authorization!
+
+    let(:order) { create(:order, number: "R123456789") }
+
+    before { allow(Spree::Order).to receive(:find_by_number!) { order } }
+
+    context "#update" do
+      it "updates + progresses the order" do
+        expect(order).to receive(:update_attributes) { true }
+        expect(order).to receive(:next) { false }
+        attributes = { order_id: order.number, order: { email: "" } }
+        spree_put :update, attributes
+      end
+
+      it "does refresh the shipment rates with all shipping methods" do
+        expect(order).to receive(:refresh_shipment_rates)
+        attributes = { order_id: order.number, order: { email: "" } }
+        spree_put :update, attributes
+      end
+
+      # Regression spec
+      context 'completed order' do
+        let(:order) { create(:shipped_order) }
+        let(:attributes) do
+          {
+            order_id: order.number,
+            guest_checkout: 'false',
+            user_id: order.user_id,
+            order: { email: "foo@bar.com" }
+          }
+        end
+
+        it 'allows the updating of an email address' do
+          expect { spree_put :update, attributes }.to change { order.reload.email }.to eq 'foo@bar.com'
+          expect(response).to be_redirect
+        end
+      end
+
+      context "false guest checkout param" do
+        let!(:assigned_user){ create :user }
+        it "attempts to associate the user" do
+          attributes = {
+            order_id: order.number,
+            user_id: assigned_user.id,
+            guest_checkout: 'false',
+            order: { email: "" }
+          }
+
+          expect {
+            spree_put :update, attributes
+          }.to change{ order.reload.user }.to(assigned_user)
+        end
+      end
+
+      context "not false guest checkout param" do
+        it "does not attempt to associate the user" do
+          allow(order).to receive_messages(update_attributes: true,
+                                           next: false,
+                                           refresh_shipment_rates: true)
+
+          attributes = {
+            order_id: order.number,
+            order: { email: "foo@example.com" }
+          }
+
+          expect {
+            spree_put :update, attributes
+          }.not_to change{ order.reload.user }
+        end
+      end
+    end
+  end
+end