solidus_backend 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c1aabfafe249cd68514b7850b380fb72ffc3873
-  data.tar.gz: b8bede6cfb8618a491ae5ac2facd469dcbde8a70
+  metadata.gz: 3cc15db5ea4f24b80c4f82d3fbcf6c7d78480d4f
+  data.tar.gz: c8677011afd99426d09e8ae8bd1da587d3435d7f
 SHA512:
-  metadata.gz: d0c0066c0465294409254c33c2ddd182567f60d4c7f6b1f65cf2bcfba177e15f99f335145f1211211a752070790365049f32fd8659a43c9507534a66cc95daac
-  data.tar.gz: d2f71a223d8c67bb49b0b5e25ed37815586e90b14140f6e0540ff9767775b4eb4d258f4eaea46965640fd42ff079154153dcd29dd01dde529c4b7eb07a58c74f
+  metadata.gz: 07026b1e153afdc4a4ec0cb3b001b57b4bfc3ca5bf4b5d81830efc38e22c4e8a9ccca8521d49ba4396108de93beeec044b998f576bfc8cf84025f88325dadbdb
+  data.tar.gz: 2149d733ca7ca912df33a5cbd2b9bec3221c4101a97bd53241f3d925efab172abbb4dd0bca3adc582dfeb589a37a2a3ff08ea22ac743e4a84ce2d4d26ff25503

data/CHANGELOG.md

@@ -0,0 +1 @@
+## Spree 2.4.0 (unreleased) ##

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,28 @@
+# 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
+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