solidus_backend 1.0.7 → 1.1.0.beta1

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

@@ -1,309 +0,0 @@
-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

@@ -1,236 +0,0 @@
-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