tb_core 1.3.0.beta2 → 1.3.0

data/spec/controllers/admin/dashboard_controller_spec.rb

@@ -1,6 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
+
+RSpec.describe Admin::DashboardController, :type => :controller do
 
-describe Admin::DashboardController do
   before(:all) do
     Spud::Core.admin_applications += [{
       :name => 'Test App',
@@ -10,19 +11,17 @@ describe Admin::DashboardController do
     {
       :name => "dash app",
       :key => 'dash_app',
-      :badge => ->(user) { return 1 }
+      :badge => ->(user){ 1 }
     }]
   end
 
   before(:each) do
     activate_authlogic
-    @user = FactoryGirl.create(:spud_user)
-    @user.role = FactoryGirl.create(:spud_role)
-    @user.save()
+    @user = FactoryGirl.create(:spud_user, :role => FactoryGirl.create(:spud_role))
     SpudUserSession.create(@user)
   end
 
-  describe :index do
+  describe 'index' do
     it "should display applications the current user has access to given that the current user is not a super admin" do
       @user.super_admin = false
       @user.role.permission_tags = ['admin.users.full_access']
@@ -30,7 +29,7 @@ describe Admin::DashboardController do
       @user.save()
       get :index
 
-      assigns(:admin_applications).collect{|app| app[:name] }.should =~ ['Users']
+      expect(assigns(:admin_applications).collect{|app| app[:name] }).to include('Users')
     end
 
     it "should not display applications the current user does not have access to given that the current user is not a super admin" do
@@ -40,7 +39,7 @@ describe Admin::DashboardController do
       @user.save()
       get :index
 
-      assigns(:admin_applications).collect{|app| app[:name] }.should_not include(:test_app)
+      expect(assigns(:admin_applications).collect{|app| app[:name] }).to_not include('Test App')
     end
 
     it "should display all the applications despite the users permissions given the current user is a super admin" do
@@ -49,83 +48,15 @@ describe Admin::DashboardController do
       @user.save
       get :index
 
-      assigns(:admin_applications).collect{|app| app[:name] }.should =~ Spud::Core.admin_applications.collect{|app| app[:name] }
-    end
-  end
-
-  describe :switch do
-    before(:each) do
-      Spud::Core.configure do |config|
-        config.site_name = "Test Site"
-        config.multisite_mode_enabled = true
-      end
-      @user.super_admin = true
-      @user.save
-    end
-
-    context "when multisite select is not set" do
-      it "should clear the session admin site" do
-        get :switch, :multisite_select => nil
-        session[:admin_site].should == 0
-      end
-
-      it "should redirect to the referer" do
-        get :switch, :multisite_select => nil
-        response.should be_redirect
-      end
-    end
-
-    context "when multisite select is set" do
-      context "and the selected site is configured" do
-        before(:each) do
-          Spud::Core.configure do |config|
-            config.site_name = "Test Site"
-            config.multisite_mode_enabled = true
-            config.multisite_config = [{:hosts => ["test.host"], :site_name =>"Site B", :site_id => 1}]
-
-          end
-        end
-
-        it "should set the session's admin site" do
-          get :switch, :multisite_select => 1
-          session[:admin_site].should == 1
-
-        end
-
-        it "should redirect" do
-          get :switch, :multisite_select => 1
-          response.should be_redirect
-        end
-      end
-
-      context "and the selected site is not configured" do
-        before(:each) do
-          Spud::Core.configure do |config|
-            config.site_name = "Test Site"
-            config.multisite_mode_enabled = true
-            config.multisite_config = []
-          end
-        end
-
-        it "should set a flash error" do
-          get :switch, :multisite_select => 1
-          flash[:error].should_not be_blank
-        end
-
-        it "should redirect" do
-          get :switch, :multisite_select => 1
-          response.should be_redirect
-        end
-      end
+      expect(assigns(:admin_applications).collect{|app| app[:name] }).to eq(Spud::Core.admin_applications.collect{|app| app[:name] })
     end
   end
 
-  describe :badges do
+  describe 'badges' do
     before(:each) do
       request.accept = "application/json"
       Spud::Core.configure do |config|
         config.site_name = "Test Site"
-        config.multisite_mode_enabled = true
       end
       @user.super_admin = true
       @user.save
@@ -133,13 +64,14 @@ describe Admin::DashboardController do
 
     it "should respond with a json content type" do
       get :badges
-      response.content_type.should eq("application/json")
+      
     end
 
     it "should contain data array in reponse" do
       get :badges
       json = JSON.parse(response.body)
-      assert json.has_key?("data")
+      expect(response.content_type).to eq("application/json")
+      expect(json).to have_key('data')
     end
 
     it "should have badge count 1 for dash app" do

data/spec/controllers/admin/password_reset_controller_spec.rb

@@ -1,91 +1,86 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::PasswordResetsController do
-  let(:user) { FactoryGirl.build(:spud_user, :id => 1) }
+describe Admin::PasswordResetsController, :type => :controller do
 
-  context :get do
-    describe :index do
+  let(:user) { FactoryGirl.build(:spud_user, :id => 1, :perishable_token => "jfdlsafhbkvabuadfbds") }
+
+  context 'get' do
+    describe 'index' do
       it "should return success" do
         get :index
-        response.should be_success
+        expect(response).to be_success
       end
     end
 
-    describe :show do
+    describe 'show' do
       context "with a valid id" do
-        before(:all) do
-          SpudUser.stubs(:find_using_perishable_token).returns(user)
-        end
-
         it "should render the edit form" do
+          allow(SpudUser).to receive(:find_using_perishable_token).and_return(user)
           get :show, :id => 1
-          response.should be_success
+          expect(response).to be_success
         end
       end
 
       context "with an invalid id" do
-        before(:all) do
-          SpudUser.stubs(:find_using_perishable_token).returns(nil)
-        end
-
         it "should redirect to the login form" do
+          allow(SpudUser).to receive(:find_using_perishable_token).and_return(nil)
           get :show, :id => user.id
-          response.should redirect_to(admin_login_path)
+          expect(response).to redirect_to(admin_login_path)
         end
       end
     end
   end
 
-  context :post do
+  context 'post' do
 
-    describe :create do
+    describe 'create' do
       context "with a valid user email address submitted" do
-        before(:each) do
-          user.perishable_token = "jfdlsafhbkvabuadfbds"
-          SpudUser.stubs(:find_by_email).returns(user)
-        end
-
         it "should trigger the password notificiation" do
-          CoreMailer.expects(:forgot_password_notification).returns(stub(:deliver))
-          post :create, :email => user.email
+          allow(SpudUser).to receive(:find_by_email).and_return(user)
+
+          expect{ post :create, :email => user.email}.to change{
+            ActionMailer::Base.deliveries.count
+          }.by(1)
         end
 
         it "should redirect to the login form" do
+          allow(SpudUser).to receive(:find_by_email).and_return(user)
+
           post :create, :email => user.email
-          response.should redirect_to(admin_login_path)
+          expect(response).to redirect_to(admin_login_path)
         end
       end
 
       context "with an invalid user email address submitted" do
         before(:each) do
-          SpudUser.stubs(:find_by_email).returns(nil)
+          allow(SpudUser).to receive(:find_by_email).and_return(nil)
         end
         it "should re-render the password reset form" do
           post :create, :email => "invalid@email.com"
-          response.should render_template("index")
+          expect(response).to render_template("index")
         end
       end
     end
 
-    describe :update do
+    describe 'update' do
       let(:valid_data) { {:id => user.id, :spud_user => {:password => "password", :password_confirmation => "password"}}}
       let(:invalid_data) { {:id => user.id, :spud_user => {:password => "password", :password_confirmation => "drowssap"}}}
 
       before(:each) do
-        SpudUser.stubs(:find_using_perishable_token).returns(user)
+        allow(SpudUser).to receive(:find_using_perishable_token).and_return(user)
       end
 
       context "with valid password entry" do
         it "should save and redirect to the login form" do
           post :update, valid_data
-          response.should redirect_to(admin_login_path)
+          expect(response).to redirect_to(admin_login_path)
         end
       end
 
       context "with an invalid password entry" do
         it "should re-render the password form" do
           post :update, invalid_data
-          response.should render_template("show")
+          expect(response).to render_template("show")
         end
       end
     end

data/spec/controllers/admin/settings_controller_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::SettingsController do
+describe Admin::SettingsController, :type => :controller do
   before(:each) do
     activate_authlogic
     user = FactoryGirl.build(:spud_user)
@@ -8,22 +8,22 @@ describe Admin::SettingsController do
     SpudUserSession.create(user)
   end
   
-  describe :edit do
+  describe 'edit' do
     it "should respond with success" do
       get :edit
-      response.should be_success
+      expect(response).to be_success
     end
   end
   
-  describe :update do
+  describe 'update' do
     it "should redirect to the settings page with a successful update" do
       put :update, :spud_user => {:first_name => "Mike"}
-      response.should redirect_to(admin_settings_path)
+      expect(response).to redirect_to(admin_settings_path)
     end
     
     it "should put a message in the flash notice" do
       put :update, :spud_user => {:first_name => "Mike"}
-      flash[:notice].should_not be_blank
+      expect(flash[:notice]).to_not be_blank
     end
   end
 

data/spec/controllers/admin/setup_controller_spec.rb

@@ -1,39 +1,32 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::SetupController do
+describe Admin::SetupController, :type => :controller do
   
-  describe :new do
+  describe 'new' do
     it "should be successful" do
       get :new
       
-      response.should be_success
-    end
-
-    it "should set a flash error message when a spud user exists" do
-      SpudUser.stubs(:count).returns(1)
-      get :new
-      
-      flash[:error].should_not be_blank
+      expect(response).to be_success
     end
     
     it "should redirect to the admin login form when there is already a user" do
-      SpudUser.stubs(:count).returns(1)
+      allow(SpudUser).to receive(:count).and_return(1)
       get :new
       
-      response.should redirect_to(admin_login_path)
+      expect(response).to redirect_to(admin_login_path)
     end
   end
 
-  describe :create do
+  describe 'create' do
     it "should create a new user" do
-      lambda {
+      expect{
         post :create, :spud_user => FactoryGirl.attributes_for(:spud_user)
-      }.should change(SpudUser, :count).by(1)
+      }.to change(SpudUser, :count).by(1)
     end
     
     it "should redirect to the admin dashboard when first admin user has been created" do
       post :create, :spud_user => FactoryGirl.attributes_for(:spud_user)
-      response.should redirect_to(admin_root_path)
+      expect(response).to redirect_to(admin_root_path)
     end
   end
 end

data/spec/controllers/admin/user_sessions_controller_spec.rb

@@ -1,52 +1,52 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::UserSessionsController do
+describe Admin::UserSessionsController, :type => :controller do
   before(:each) do
     # activate_authlogic
     # SpudUserSession.create(FactoryGirl.build(:spud_user))
   end
 
-  describe :new do
+  describe 'new' do
     it "should redirect to setup url if no users exist" do
       get :new
-      response.should redirect_to(admin_setup_path)
+      expect(response).to redirect_to(admin_setup_path)
     end
 
     it "should render login form if users do exist" do
       u = FactoryGirl.create(:spud_user)
       u.save
       get :new
-      response.should be_success
+      expect(response).to be_success
     end
   end
 
-  describe :create do
+  describe 'create' do
     it "should rerender form when login is invalid" do
       post :create
-        response.should be_success
+        expect(response).to be_success
     end
     it "should redirect to admin root if login is valid" do
       u = FactoryGirl.create(:spud_user,:login => "testuser")
       u.save
       user_session = {:login => "testuser", :password => "password"}
       post :create, :spud_user_session => user_session
-      response.should redirect_to(admin_root_path)
+      expect(response).to redirect_to(admin_root_path)
     end
   end
 
-  describe :destroy do
+  describe 'destroy' do
     it "should redirect to login after logout when no referer" do
       activate_authlogic
       SpudUserSession.create(FactoryGirl.build(:spud_user))
       delete :destroy
-      response.should redirect_to(admin_login_path)
+      expect(response).to redirect_to(admin_login_path)
     end
     it "should redirect to the admin login page after logout" do
         request.env["HTTP_REFERER"] = "/"
         activate_authlogic
       SpudUserSession.create(FactoryGirl.build(:spud_user))
       delete :destroy
-      response.should redirect_to("/admin/login")
+      expect(response).to redirect_to("/admin/login")
     end
   end
 end

data/spec/controllers/admin/users_controller_spec.rb

@@ -1,6 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
+
+describe Admin::UsersController, :type => :controller do
 
-describe Admin::UsersController do
   before(:each) do
     activate_authlogic
     @user = SpudUserSession.create(FactoryGirl.build(:spud_user, :super_admin => true))
@@ -9,26 +10,26 @@ describe Admin::UsersController do
     Spud::Core.permissions.push(SpudPermission.new('admin.test.full_access', 'Test', [:test]))
   end
   
-  describe :index do
+  describe 'index' do
     it "should return an array of users" do
       2.times {|x| FactoryGirl.create(:spud_user) }
       get :index
       
-      assigns(:users).count.should be > 1
+      expect(assigns(:spud_users).count).to be > 1
     end
     
     it "should not return any users if there are no users" do
       get :index
       
-      assigns(:users).count.should == 1 # the currently logged in user is the only user
+      expect(assigns(:spud_users).count).to eq(1) # the currently logged in user is the only user
     end
     
     it "should not allow access to users with NO permissions" do
       SpudUserSession.create(FactoryGirl.build(:spud_user, :super_admin => false))
       get :index
       
-      response.code.should eq("403")
-      response.should render_template('layouts/admin/error_page')
+      expect(response.code).to eq("403")
+      expect(response).to render_template('layouts/admin/error_page')
     end
     
     it "should allow access to users with the correct permissions" do
@@ -39,7 +40,7 @@ describe Admin::UsersController do
       SpudUserSession.create(u)
       get :index
       
-      response.should be_success
+      expect(response).to be_success
     end
 
     it "should not allow access to users without a role, and redirect to render error page if the user has no permissions" do
@@ -48,8 +49,8 @@ describe Admin::UsersController do
       SpudUserSession.create(u)
       get :index
       
-      response.code.should eq("403")
-      response.should render_template('layouts/admin/error_page')
+      expect(response.code).to eq("403")
+      expect(response).to render_template('layouts/admin/error_page')
     end
 
     it "should not allow access to users with a role that contains no permissions, and render error page if the users has no other admin modules" do
@@ -59,8 +60,8 @@ describe Admin::UsersController do
       SpudUserSession.create(u)
       get :index
       
-      response.code.should eq("403")
-      response.should render_template('layouts/admin/error_page')
+      expect(response.code).to eq("403")
+      expect(response).to render_template('layouts/admin/error_page')
     end
     
     it "should not allow access to users without permission and render error page if the users has other admin modules" do
@@ -70,113 +71,87 @@ describe Admin::UsersController do
       SpudUserSession.create(u)
       get :index
       
-      response.code.should eq("403")
-      response.should render_template('layouts/admin/error_page')
+      expect(response.code).to eq("403")
+      expect(response).to render_template('layouts/admin/error_page')
     end
   end
   
-  describe :show do
+  describe 'show' do
     it "should respond successfully" do
       user = FactoryGirl.create(:spud_user)
       get :show, :id => user.id
-      
-      response.should be_success
-    end
-    
-    it "should show the user" do
-      user = FactoryGirl.create(:spud_user)
-      get :show, :id => user.id
-      
-      assigns(:user).id.should == user.id
+      expect(response).to be_success
     end
   end
   
-  describe :new do
-    it "should respond successfully" do
-      get :new, :format => :js
-      
-      response.should be_success
-    end
-    
-    it "should build a user object for the form" do
-      get :new, :format => :js
-      
-      assigns(:user).should_not be_blank
+  describe 'new' do
+    it "should render the form" do
+      get :new, :format => :html
+      expect(response).to be_success
     end
   end
   
-  describe :create do
+  describe 'create' do
     context "HTML format" do
       it "should create a new user with a valid form submission" do
-        lambda {
+        expect {
           post :create, :spud_user => FactoryGirl.attributes_for(:spud_user)
-        }.should change(SpudUser, :count).by(1)
-        response.should be_success
+        }.to change(SpudUser, :count).by(1)
+        expect(response).to be_success
       end
     
       it "should not create a user with an invalid form entry" do
-        lambda {
+        expect {
           post :create, :spud_user => FactoryGirl.attributes_for(:spud_user, :email => nil)
-        }.should_not change(SpudUser, :count)
+        }.to_not change(SpudUser, :count)
       end
     end    
   end
   
-  describe :edit do
+  describe 'edit' do
     context "HTML format" do
       it "should load the correct user for the edit form" do
         user = FactoryGirl.create(:spud_user)
         get :edit, :id => user.id
       
-        assigns(:user).id.should == user.id
-      end
-    end
-
-    context "JS format" do
-      it "should load the correct user for the edit form" do
-        user = FactoryGirl.create(:spud_user)
-        get :edit, :id => user.id, :format => :js
-      
-        assigns(:user).id.should == user.id
+        expect(assigns(:user).id).to eq(user.id)
       end
-      
     end
-
   end
   
-  describe :update do
+  describe 'update' do
     it "should update the email when the first name attribute is changed" do
       user = FactoryGirl.create(:spud_user)
       new_name = "Adam"
-      lambda {
+      expect {
         put :update, :id => user.id, :spud_user => user.attributes.merge!(:first_name => new_name)
         user.reload
-      }.should change(user, :first_name).to(new_name)
+      }.to change(user, :first_name).to(new_name)
     end
     
     it "should redirect to the admin users show view after a successful update" do
       user = FactoryGirl.create(:spud_user)
       put :update, :id => user.id, :spud_user => user.attributes.merge!(:first_name => "Adam")
       
-      response.should redirect_to(admin_user_path(user))
+      expect(response).to redirect_to(admin_user_path(user))
     end
   end
   
-  describe :destroy do
+  describe 'destroy' do
     it "should destroy the user" do
       user = FactoryGirl.create(:spud_user)
-      lambda {
+      expect {
         delete :destroy, :id => user.id
-      }.should change(SpudUser, :count).by(-1)
-      response.should be_redirect
+      }.to change(SpudUser, :count).by(-1)
+      expect(response).to be_redirect
     end
     
     it "should destroy the user with the wrong id" do
       user = FactoryGirl.create(:spud_user)
-      lambda {
+      expect {
         delete :destroy, :id => "23532"
-      }.should_not change(SpudUser, :count)
-      response.should be_redirect
+      }.to_not change(SpudUser, :count)
+      expect(response).to be_redirect
     end
   end
 end

data/spec/controllers/spud/application_controller_spec.rb

@@ -1,14 +1,14 @@
-require 'spec_helper'
+require 'rails_helper'
 require 'rspec/mocks'
 require 'rspec/mocks/standalone'
 
-describe Spud::ApplicationController do
+describe Spud::ApplicationController, :type => :controller do
 
-  describe :not_found do
+  describe 'not_found' do
     it 'throws a 404 error' do
       get :not_found
-      response.code.should eq("404")
-      response.should render_template('layouts/error_page')
+      expect(response.code).to eq('404')
+      expect(response).to render_template('layouts/error_page')
     end
   end
 

data/spec/dummy/app/assets/javascripts/admin/application.js

@@ -0,0 +1,16 @@
+//= require_self
+//= require_tree
+
+(function(){
+
+window.app = {
+  admin: {
+    init: function(){
+
+    }
+  }
+};
+
+$(document).ready(app.admin.init);
+
+})();