solidus_backend 1.0.2 → 1.0.3

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

@@ -0,0 +1,309 @@
+require 'spec_helper'
+
+shared_examples "update reason loader" do
+  it "sets the update_reasons variable to a list of categories sorted by category name " do
+    expect(assigns(:update_reasons)).to eq [update_reason]
+  end
+end
+
+describe Spree::Admin::StoreCreditsController do
+  stub_authorization!
+
+  let(:user) { create(:user) }
+  let(:admin_user) { create(:admin_user) }
+
+  let!(:b_credit_category) { create(:store_credit_category, name: "B category") }
+  let!(:a_credit_category) { create(:store_credit_category, name: "A category") }
+  let!(:update_reason)     { create(:store_credit_update_reason) }
+
+  describe "#show" do
+    let!(:store_credit) { create(:store_credit, user: user, category: a_credit_category) }
+    let!(:event)        { create(:store_credit_auth_event, store_credit: store_credit, created_at: 5.days.ago) }
+
+    before { spree_get :show, user_id: user.id, id: store_credit.id }
+
+    it "sets the store_credit variable to a new store credit model" do
+      expect(assigns(:store_credit)).to eq store_credit
+    end
+
+    it "sets the store_credit_events variable to the store credit's events in chronological order" do
+      allocation_event = store_credit.store_credit_events.find_by(action: Spree::StoreCredit::ALLOCATION_ACTION)
+      expect(assigns(:store_credit_events)).to eq [event, allocation_event]
+    end
+  end
+
+  describe "#new" do
+    before { spree_get :new, user_id: create(:user).id }
+    it { expect(assigns(:credit_categories)).to eq [a_credit_category, b_credit_category] }
+  end
+
+  describe "#create" do
+
+    subject { spree_post :create, parameters }
+
+    before  {
+      allow(controller).to receive_messages(try_spree_current_user: admin_user)
+      create(:primary_credit_type)
+    }
+
+    context "the passed parameters are valid" do
+      let(:parameters) do
+        {
+          user_id: user.id,
+          store_credit: {
+            amount: 1.00,
+            category_id: a_credit_category.id
+          }
+        }
+      end
+
+      it "creates a new store credit" do
+        expect { subject }.to change(Spree::StoreCredit, :count).by(1)
+      end
+
+      it "associates the store credit with the user" do
+        subject
+        expect(user.reload.store_credits.count).to eq 1
+      end
+
+      it "assigns the store credit's created by to the current user" do
+        subject
+        expect(user.reload.store_credits.first.created_by).to eq admin_user
+      end
+
+      it 'sets the admin as the store credit event originator' do
+        expect { subject }.to change { Spree::StoreCreditEvent.count }.by(1)
+        expect(Spree::StoreCreditEvent.last.originator).to eq admin_user
+      end
+    end
+
+    context "the passed parameters are invalid" do
+      let(:parameters) do
+        {
+          user_id: user.id,
+          store_credit: {
+            amount: -1.00,
+            category_id: a_credit_category.id
+          }
+        }
+      end
+
+      it { expect { subject }.not_to change(Spree::StoreCredit, :count) }
+    end
+  end
+
+  describe "#edit_amount" do
+    let!(:store_credit)      { create(:store_credit, user: user, category: a_credit_category) }
+
+    before { spree_get :edit_amount, user_id: user.id, id: store_credit.id }
+
+    it_behaves_like "update reason loader"
+
+    it "sets the store_credit variable to the persisted store credit" do
+      expect(assigns(:store_credit)).to eq store_credit
+    end
+  end
+
+  describe "#edit_validity" do
+    let!(:store_credit)      { create(:store_credit, user: user, category: a_credit_category) }
+
+    before { spree_get :edit_validity, user_id: user.id, id: store_credit.id }
+
+    it_behaves_like "update reason loader"
+
+    it "sets the store_credit variable to the persisted store credit" do
+      expect(assigns(:store_credit)).to eq store_credit
+    end
+  end
+
+  describe "#update" do
+    let(:memo)          { "New memo" }
+    let!(:store_credit) { create(:store_credit, user: user) }
+
+    subject { spree_put :update, parameters.merge(format: :json) }
+
+    before  { allow(controller).to receive_messages(try_spree_current_user: admin_user) }
+
+    context "the passed parameters are valid" do
+      let(:parameters) do
+        {
+          user_id: user.id,
+          id: store_credit.id,
+          store_credit: {
+            memo: memo
+          }
+        }
+      end
+
+      it "updates the memo to be the passed in value" do
+        expect { subject }.to change { store_credit.reload.memo }.to(memo)
+      end
+
+      it "returns a success message" do
+        subject
+        expect(response).to have_http_status(:ok)
+        expect(JSON.parse(response.body)['message']).to match("Store credit has been successfully updated!")
+      end
+    end
+
+    context "the passed parameters are invalid" do
+      let(:parameters) do
+        {
+          user_id: user.id,
+          id: store_credit.id,
+          store_credit: {
+            category_id: b_credit_category.id
+          }
+        }
+      end
+      it "doesn't update the store credit's category" do
+        expect { subject }.to_not change { store_credit.reload.category }
+      end
+
+      it "returns an error message" do
+        subject
+        expect(response).to have_http_status(:bad_request)
+        expect(JSON.parse(response.body)['message']).to match("Unable to update store credit")
+      end
+    end
+  end
+
+  describe "#update_amount" do
+    let(:original_amount) { 100.0 }
+    let!(:store_credit)   { create(:store_credit, user: user, amount: original_amount) }
+    let!(:update_reason)  { create(:store_credit_update_reason) }
+    let(:parameters) do
+      {
+        user_id: user.id,
+        id: store_credit.id,
+        update_reason_id: update_reason.id,
+        store_credit: {
+          amount: updated_amount
+        }
+      }
+    end
+
+    subject { spree_put :update_amount, parameters }
+
+    before  { allow(controller).to receive_messages(try_spree_current_user: admin_user) }
+
+    context "the passed parameters are valid" do
+      let(:updated_amount) { 300.0 }
+
+      context "the store credit has been partially used" do
+        before { store_credit.update_attributes(amount_used: 10.0) }
+
+        context "the new amount is greater than the used amount" do
+          let(:updated_amount) { 11.0 }
+
+          before { subject }
+
+          it "updates the amount to be the passed in amount" do
+            expect(store_credit.reload.amount).to eq updated_amount
+          end
+        end
+
+        context "the new amount is less than the used amount" do
+          let(:updated_amount) { 9.0 }
+
+          before { subject }
+
+          it "does not update the amount" do
+            expect(store_credit.reload.amount).to eq original_amount
+          end
+
+          it "renders the edit_amount template" do
+            expect(response).to render_template :edit_amount
+          end
+
+          it "adds an error message to the flash" do
+            expect(flash.now[:error]).to match "Unable to update"
+          end
+
+          it_behaves_like "update reason loader"
+        end
+      end
+
+      context "the store credit has not been used" do
+        it "sets a success message in the flash" do
+          subject
+          expect(flash.now[:success]).to match "Store credit has been successfully updated!"
+        end
+
+        it "does not create a new store credit" do
+          expect { subject }.to_not change(Spree::StoreCredit, :count)
+        end
+
+        it "updates passed amount" do
+          subject
+          expect(store_credit.reload.amount).to eq updated_amount
+        end
+      end
+    end
+
+    context "the passed parameters are invalid" do
+      let(:updated_amount) { -1.00 }
+
+      before { subject }
+
+      it "does not update the amount" do
+        expect(store_credit.reload.amount).to eq original_amount
+      end
+
+      it "renders the edit_amount template" do
+        expect(response).to render_template :edit_amount
+      end
+
+      it "adds an error message to the flash" do
+        expect(flash.now[:error]).to match "Unable to update"
+      end
+
+      it_behaves_like "update reason loader"
+    end
+  end
+
+  describe "#invalidate" do
+    let!(:store_credit) { create(:store_credit, user: user, category: b_credit_category) }
+
+    let(:parameters) do
+      {
+        user_id: user.id,
+        id: store_credit.id,
+        update_reason_id: update_reason.id
+      }
+    end
+
+    subject { spree_put :invalidate, parameters }
+
+    it "attempts to invalidate the store credit" do
+      expect { subject  }.to change { store_credit.reload.invalidated_at }.from(nil)
+    end
+
+    context "the invalidation is unsuccessful" do
+      before do
+        store_credit.authorize(5.0, "USD")
+        subject
+      end
+
+      it "doesn't invalidate the store credit" do
+        expect(store_credit.reload.invalidated_at).to be_nil
+      end
+
+      it "renders the edit_validity template" do
+        expect(response).to render_template :edit_validity
+      end
+
+      it "sets an error message in the flash" do
+        expect(flash.now[:error]).to match "Unable to invalidate store credit"
+      end
+
+      it_behaves_like "update reason loader"
+    end
+
+    context "the invalidation is successful" do
+      it "redirects to index" do
+        expect(subject).to redirect_to spree.admin_user_store_credit_path(user, store_credit)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+require 'spec_helper'
+require 'spree/testing_support/bar_ability'
+
+describe Spree::Admin::UsersController, :type => :controller do
+  let(:user) { create(:user) }
+  let(:mock_user) { mock_model Spree.user_class }
+
+  before do
+    allow(controller).to receive_messages :spree_current_user => user
+    user.spree_roles.clear
+  end
+
+  context "#show" do
+    before do
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+    end
+
+    it "redirects to edit" do
+      spree_get :show, id: user.id
+      expect(response).to redirect_to spree.edit_admin_user_path(user)
+    end
+  end
+
+  context '#authorize_admin' do
+    before { use_mock_user }
+
+    it 'grant access to users with an admin role' do
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+      spree_post :index
+      expect(response).to render_template :index
+    end
+
+    it "allows admins to update a user's API key" do
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+      expect(mock_user).to receive(:generate_spree_api_key!).and_return(true)
+      spree_put :generate_api_key, id: mock_user.id
+      expect(response).to redirect_to(spree.edit_admin_user_path(mock_user))
+    end
+
+    it "allows admins to clear a user's API key" do
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+      expect(mock_user).to receive(:clear_spree_api_key!).and_return(true)
+      spree_put :clear_api_key, id: mock_user.id
+      expect(response).to redirect_to(spree.edit_admin_user_path(mock_user))
+    end
+
+    it 'deny access to users with an bar role' do
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
+      Spree::Ability.register_ability(BarAbility)
+      spree_post :index
+      expect(response).to redirect_to '/unauthorized'
+    end
+
+    it 'deny access to users with an bar role' do
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'bar')
+      Spree::Ability.register_ability(BarAbility)
+      spree_post :update, { id: '9' }
+      expect(response).to redirect_to '/unauthorized'
+    end
+
+    it 'deny access to users without an admin role' do
+      allow(user).to receive_messages :has_spree_role? => false
+      spree_post :index
+      expect(response).to redirect_to '/unauthorized'
+    end
+  end
+
+  describe "#create" do
+    let(:dummy_role) { Spree::Role.create(name: "dummyrole") }
+
+    before do
+      use_mock_user
+      allow(mock_user).to receive_messages(:spree_roles= => true, :stock_locations= => true)
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+    end
+
+    context "when the user can manage roles" do
+      it "can set roles" do
+        expect(mock_user).to receive(:spree_roles=).with([dummy_role])
+        spree_post :create, { id: mock_user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+      end
+
+      it "can clear roles" do
+        expect(mock_user).to receive(:spree_roles=).with([])
+        spree_post :create, { id: mock_user.id, user: { first_name: "Bob"}  }
+      end
+    end
+
+    context "when the user cannot manage roles" do
+      before do
+        user.spree_roles = [Spree::Role.find_or_create_by(name: "user_management")]
+      end
+
+      it "cannot set roles" do
+        expect(mock_user).to_not receive(:spree_roles=)
+        spree_post :create, { user: { spree_role_ids: [dummy_role.id] } }
+      end
+
+      it "cannot set roles" do
+        expect(mock_user).to_not receive(:spree_roles=)
+        spree_post :create, { id: mock_user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+      end
+
+      it "cannot clear roles" do
+        expect(mock_user).to_not receive(:spree_roles=)
+        spree_post :create, { id: mock_user.id, user: { first_name: "Bob"}  }
+      end
+    end
+
+    it "can create a shipping_address" do
+      expect(Spree.user_class).to receive(:new).with(hash_including(
+        "ship_address_attributes" => { "city" => "New York" }
+      ))
+      spree_post :create, { :user => { :ship_address_attributes => { :city => "New York" } } }
+    end
+
+    it "can create a billing_address" do
+      expect(Spree.user_class).to receive(:new).with(hash_including(
+        "bill_address_attributes" => { "city" => "New York" }
+      ))
+      spree_post :create, { :user => { :bill_address_attributes => { :city => "New York" } } }
+    end
+
+    it "can set stock locations" do
+      location = Spree::StockLocation.create(name: "my_location")
+      location_2 = Spree::StockLocation.create(name: "my_location_2")
+      expect(mock_user).to receive(:stock_locations=).with([location, location_2])
+      spree_post :create, { user: { stock_location_ids: [location.id, location_2.id] } }
+    end
+  end
+
+  describe "#update" do
+    let(:dummy_role) { Spree::Role.create(name: "dummyrole") }
+    before do
+      use_mock_user
+      allow(mock_user).to receive_messages(:spree_roles= => true, :stock_locations= => true)
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+    end
+
+    context "when the user can manage roles" do
+      it "can set roles" do
+        expect(mock_user).to receive(:spree_roles=).with([dummy_role])
+        spree_put :update, { id: mock_user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+      end
+
+      it "can clear roles" do
+        expect(mock_user).to receive(:spree_roles=).with([])
+        spree_put :update, { id: mock_user.id, user: { first_name: "Bob"}  }
+      end
+    end
+
+    context "when the user cannot manage roles" do
+      before do
+        user.spree_roles = [Spree::Role.find_or_create_by(name: "user_management")]
+      end
+
+      it "cannot set roles" do
+        expect(mock_user).to_not receive(:spree_roles=)
+        spree_put :update, { id: mock_user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+      end
+
+      it "cannot clear roles" do
+        expect(mock_user).to_not receive(:spree_roles=)
+        spree_put :update, { id: mock_user.id, user: { first_name: "Bob" }  }
+      end
+    end
+
+    it "allows shipping address attributes through" do
+      expect(mock_user).to receive(:update_attributes).with(hash_including(
+        "ship_address_attributes" => { "city" => "New York" }
+      ))
+      spree_put :update, { :id => mock_user.id, :user => { :ship_address_attributes => { :city => "New York" } } }
+    end
+
+    it "allows billing address attributes through" do
+      expect(mock_user).to receive(:update_attributes).with(hash_including(
+        "bill_address_attributes" => { "city" => "New York" }
+      ))
+      spree_put :update, { :id => mock_user.id, :user => { :bill_address_attributes => { :city => "New York" } } }
+    end
+
+    it "can set stock locations" do
+      location = Spree::StockLocation.create(name: "my_location")
+      location_2 = Spree::StockLocation.create(name: "my_location_2")
+      expect(mock_user).to receive(:stock_locations=).with([location, location_2])
+      spree_put :update, { id: mock_user.id, user: { stock_location_ids: [location.id, location_2.id] } }
+    end
+  end
+
+  describe "#orders" do
+    let(:order) { create(:order) }
+    before do
+      user.orders << order
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+    end
+
+    it "assigns a list of the users orders" do
+      spree_get :orders, { :id => user.id }
+      expect(assigns[:orders].count).to eq 1
+      expect(assigns[:orders].first).to eq order
+    end
+
+    it "assigns a ransack search for Spree::Order" do
+      spree_get :orders, { :id => user.id }
+      expect(assigns[:search]).to be_a Ransack::Search
+      expect(assigns[:search].klass).to eq Spree::Order
+    end
+  end
+
+  describe "#items" do
+    let(:order) { create(:order) }
+    before do
+      user.orders << order
+      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+    end
+
+    it "assigns a list of the users orders" do
+      spree_get :items, { :id => user.id }
+      expect(assigns[:orders].count).to eq 1
+      expect(assigns[:orders].first).to eq order
+    end
+
+    it "assigns a ransack search for Spree::Order" do
+      spree_get :items, { :id => user.id }
+      expect(assigns[:search]).to be_a Ransack::Search
+      expect(assigns[:search].klass).to eq Spree::Order
+    end
+  end
+end
+
+def use_mock_user
+  allow(mock_user).to receive(:save).and_return(true)
+  allow(mock_user).to receive(:update_attributes).and_return(true)
+  allow(Spree.user_class).to receive(:find).with(mock_user.id.to_s).and_return(mock_user)
+  allow(Spree.user_class).to receive(:new).and_return(mock_user)
+end