solidus_backend 1.3.2 → 1.4.0.beta1

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

@@ -3,255 +3,253 @@ 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
+  let(:state) { create(:state, state_code: 'NY') }
+  let(:valid_address_attributes) do
+    {
+      firstname: 'Foo',
+      lastname: 'Bar',
+      city: "New York",
+      country_id: state.country.id,
+      state_id: state.id,
+      phone: '555-555-5555',
+      address1: '123 Fake St.',
+      zipcode: '10001',
+    }
   end
 
   context "#show" do
-    before do
-      user.spree_roles << Spree::Role.find_or_create_by(name: 'admin')
+    stub_authorization! do |_user|
+      can [:admin, :manage], Spree.user_class
     end
 
     it "redirects to edit" do
-      spree_get :show, id: user.id
+      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
+    context "with ability to admin users" do
+      stub_authorization! do |_user|
+        can [:manage], Spree.user_class
+      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 'can visit index' do
+        post :index
+        expect(response).to be_success
+      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 "allows admins to update a user's API key" do
+        expect {
+          put :generate_api_key, id: user.id
+        }.to change { user.reload.spree_api_key }
+        expect(response).to redirect_to(spree.edit_admin_user_path(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'
+      it "allows admins to clear a user's API key" do
+        user.generate_spree_api_key!
+        expect {
+          put :clear_api_key, id: user.id
+        }.to change{ user.reload.spree_api_key }.to(nil)
+        expect(response).to redirect_to(spree.edit_admin_user_path(user))
+      end
     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
+    context "without ability to admin users" do
+      stub_authorization! do |_user|
+      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'
+      it 'denies access' do
+        post :index
+        expect(response).to redirect_to '/unauthorized'
+      end
     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')
+    # The created user
+    def user
+      Spree.user_class.last
+    end
+
+    stub_authorization! do |_user|
+      can :manage, Spree.user_class
     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] } }
+      stub_authorization! do |_user|
+        can :manage, Spree.user_class
+        can :manage, Spree::Role
       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" } }
+      it "can create user with roles" do
+        post :create, { user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+        expect(user.spree_roles).to eq([dummy_role])
       end
-    end
 
-    context "when the user cannot manage roles" do
-      before do
-        user.spree_roles = [Spree::Role.find_or_create_by(name: "user_management")]
+      it "can create user without roles" do
+        post :create, { user: { first_name: "Bob" } }
+        expect(user.spree_roles).to eq([])
       end
+    end
 
-      it "cannot set roles" do
-        expect(mock_user).to_not receive(:spree_roles=)
-        spree_post :create, { user: { spree_role_ids: [dummy_role.id] } }
+    context "when the user cannot manage roles" do
+      it "cannot assign users roles" do
+        post :create, { user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+        expect(user.spree_roles).to eq([])
       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" } }
+      it "can create user without roles" do
+        post :create, { user: { first_name: "Bob" } }
+        expect(user.spree_roles).to eq([])
       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" } } }
+      post :create, { user: { ship_address_attributes: valid_address_attributes } }
+      expect(user.reload.ship_address.city).to eq('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" } } }
+      post :create, { user: { bill_address_attributes: valid_address_attributes } }
+      expect(user.reload.bill_address.city).to eq('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] } }
+      post :create, { user: { stock_location_ids: [location.id, location_2.id] } }
+      expect(user.stock_locations).to match_array([location, location_2])
     end
   end
 
   describe "#update" do
     let(:dummy_role) { Spree::Role.create(name: "dummyrole") }
     let(:ability) { Spree::Ability.new(user) }
-    before do
-      use_mock_user
-      allow(mock_user).to receive_messages(:spree_roles= => true, :stock_locations= => true)
-      allow(controller).to receive(:current_ability) { ability }
-      Spree::PermissionSets::UserManagement.new(ability).activate!
+
+    stub_authorization! do |_user|
+      can :manage, Spree.user_class
     end
 
-    context "as a superuser" do
-      before { Spree::PermissionSets::SuperUser.new(ability).activate! }
+    context "when the user can manage roles" do
+      stub_authorization! do |_user|
+        can :manage, Spree.user_class
+        can :manage, Spree::Role
+      end
 
       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] } }
+        expect {
+          put :update, { id: user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+        }.to change { user.reload.spree_roles.to_a }.to([dummy_role])
       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" } }
+        user.spree_roles << dummy_role
+        expect {
+          put :update, { id: user.id, user: { first_name: "Bob", spree_role_ids: [] } }
+        }.to change { user.reload.spree_roles.to_a }.to([])
       end
+    end
 
-      it "can change email of a user with no roles" do
-        expect(mock_user).to receive(:update_attributes).with({ email: "bob@example.com" })
-        spree_put :update, { id: mock_user.id, user: { email: "bob@example.com" } }
+    context "when the user cannot manage roles" do
+      it "cannot set roles" do
+        expect {
+          put :update, { id: user.id, user: { first_name: "Bob", spree_role_ids: [dummy_role.id] } }
+        }.not_to change { user.reload.spree_roles.to_a }
       end
 
-      it "can change email of a user with roles" do
-        allow(mock_user).to receive(:spree_roles) { [dummy_role] }
-        expect(mock_user).to receive(:update_attributes).with({ email: "bob@example.com" })
-        spree_put :update, { id: mock_user.id, user: { email: "bob@example.com" } }
+      it "cannot clear roles" do
+        user.spree_roles << dummy_role
+        expect {
+          put :update, { id: user.id, user: { first_name: "Bob" } }
+        }.not_to change { user.reload.spree_roles.to_a }
       end
     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
+    context "allowed to update email" do
+      stub_authorization! do |_user|
+        can [:admin, :update, :update_email], Spree.user_class
+      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" } }
+      it "can change email of a user" do
+        expect {
+          put :update, { id: user.id, user: { email: "bob@example.com" } }
+        }.to change { user.reload.email }.to("bob@example.com")
+      end
     end
 
-    it "can change email of a user with no roles" do
-      expect(mock_user).to receive(:update_attributes).with({ email: "bob@example.com" })
-      spree_put :update, { id: mock_user.id, user: { email: "bob@example.com" } }
-    end
+    context "not allowed to update email" do
+      stub_authorization! do |_user|
+        can [:admin, :update], Spree.user_class
+      end
 
-    it "cannot change email of a user with roles" do
-      allow(mock_user).to receive(:spree_roles) { [dummy_role] }
-      expect(mock_user).to receive(:update_attributes).with({})
-      spree_put :update, { id: mock_user.id, user: { email: "bob@example.com" } }
+      it "cannot change email of a user" do
+        expect {
+          put :update, { id: user.id, user: { email: "bob@example.com" } }
+        }.not_to change { user.reload.email }
+      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" } } }
+    it "can update ship_address attributes" do
+      post :update, { id: user.id, user: { ship_address_attributes: valid_address_attributes } }
+      expect(user.reload.ship_address.city).to eq('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" } } }
+    it "can update bill_address attributes" do
+      post :update, { id: user.id, user: { bill_address_attributes: valid_address_attributes } }
+      expect(user.reload.bill_address.city).to eq('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] } }
+      post :update, { id: user.id, user: { stock_location_ids: [location.id, location_2.id] } }
+      expect(user.stock_locations).to match_array([location, location_2])
     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')
+    stub_authorization! do |_user|
+      can :manage, Spree.user_class
     end
 
+    let(:order) { create(:order) }
+    before { user.orders << order }
+
     it "assigns a list of the users orders" do
-      spree_get :orders, { id: user.id }
+      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 }
+      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')
+    stub_authorization! do |_user|
+      can :manage, Spree.user_class
     end
 
+    let(:order) { create(:order) }
+    before { user.orders << order }
+
     it "assigns a list of the users orders" do
-      spree_get :items, { id: user.id }
+      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 }
+      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(mock_user).to receive(:spree_roles).and_return([])
-  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

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

@@ -14,7 +14,7 @@ module Spree
 
         context "deleted is not requested" do
           it "does not assign deleted variants for a requested product" do
-            spree_get :index, product_id: product.slug
+            get :index, product_id: product.slug
             expect(assigns(:collection)).to include variant_1
             expect(assigns(:collection)).not_to include variant_2
           end
@@ -22,7 +22,7 @@ module Spree
 
         context "deleted is requested" do
           it "assigns deleted along with non-deleted variants for a requested product" do
-            spree_get :index, product_id: product.slug, deleted: "on"
+            get :index, product_id: product.slug, deleted: "on"
             expect(assigns(:collection)).to include variant_1
             expect(assigns(:collection)).to include variant_2
           end

data/spec/features/admin/configuration/general_settings_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "General Settings", type: :feature, js: true do
+describe "Store", type: :feature, js: true do
   stub_authorization!
 
   let!(:store) do
@@ -11,19 +11,21 @@ describe "General Settings", type: :feature, js: true do
   before(:each) do
     visit spree.admin_path
     click_link "Settings"
-    click_link "General Settings"
+    within('.admin-nav') do
+      click_link "Store"
+    end
   end
 
-  context "visiting general settings" do
+  context "visiting general store settings" do
     it "should have the right content" do
-      expect(page).to have_content("General Settings")
+      expect(page).to have_content("SettingsStore")
       expect(page).to have_field("store_name", with: "Test Store")
       expect(page).to have_field("store_url", with: "test.example.org")
       expect(page).to have_field("store_mail_from_address", with: "test@example.org")
     end
   end
 
-  context "editing general settings" do
+  context "editing general store settings" do
     it "should be able to update the site name" do
       fill_in "store_name", with: "Spree Demo Site99"
       fill_in "store_mail_from_address", with: "spree@example.org"
@@ -44,15 +46,4 @@ describe "General Settings", type: :feature, js: true do
       expect(page).to have_field("Site Name", with: "")
     end
   end
-
-  context "clearing the cache" do
-    it "should clear the cache" do
-      expect(page).to_not have_content(Spree.t(:clear_cache_ok))
-      expect(page).to have_content(Spree.t(:clear_cache_warning))
-
-      click_button "Clear Cache"
-
-      expect(page).to have_content(Spree.t(:clear_cache_ok))
-    end
-  end
 end