tb_core 0.9.17

data/lib/spud_core/searchable.rb

@@ -0,0 +1,11 @@
+module Spud::Searchable
+	extend ActiveSupport::Concern
+	included do
+		extend ClassMethods
+	end
+	module ClassMethods
+		def spud_searchable
+			# puts "Place Holder For #{self.name}"
+		end
+	end
+end

data/lib/spud_core/test_files.rb

@@ -0,0 +1,25 @@
+module Spud
+  module Core
+    module TestFiles
+      class << self
+        def load_all
+          load_specs
+          load_factories
+          load_support
+        end
+        
+        def load_specs
+          Dir[File.join(File.expand_path('../../../', __FILE__), "spec/**/*_spec.rb")].each {|f| require f}
+        end
+          
+        def load_factories
+          Dir[File.join(File.expand_path('../../../', __FILE__), "factories/*")].each {|f| require f}
+        end
+        
+        def load_support
+          Dir[File.join(File.expand_path('../../../', __FILE__), "spec/support/**/*.rb")].each {|f| require f}
+        end
+      end
+    end
+  end
+end

data/lib/spud_core/version.rb

@@ -0,0 +1,5 @@
+module Spud
+	module Core
+	  VERSION = "0.9.17"
+	end
+end

data/lib/tasks/spud_core_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :spud_core do
+#   # Task goes here
+# end

data/lib/tb_core.rb

@@ -0,0 +1,6 @@
+module Tb
+   module Core
+    require 'spud_core/engine'
+    require 'spud_core/configuration'
+   end
+end

data/spec/controllers/spud/admin/application_controller_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Spud::Admin::ApplicationController do
+  
+  
+  before :each do
+    activate_authlogic
+    @user = FactoryGirl.create(:spud_user)
+    @session = SpudUserSession.create(@user)
+  end
+  
+  describe :require_admin_user do
+    controller(Spud::Admin::ApplicationController) do
+      def index
+        render :nothing => true
+      end
+    end
+    it "should respond successfully if the current user is a super admin" do
+      @user.update_attribute(:super_admin, true)
+      get :index
+      
+      response.should be_success
+    end
+    
+    it "should respond successfully if the current user has admin permissions" do
+      @user.spud_admin_permissions.create(:name => "pages", :access => true)
+      get :index
+      
+      response.should be_success
+    end
+    
+    it "should redirect to the login if the current user is not logged in" do
+      @session.destroy
+      get :index
+      
+      response.should redirect_to(new_spud_user_session_url)
+    end
+    
+    it "should redirect to the root for a user without administrative priviledges" do
+      @user.super_admin = false
+      @user.spud_admin_permissions = []
+      @user.save
+      get :index
+      
+      response.should redirect_to(root_url)
+    end
+    
+  end
+end

data/spec/controllers/spud/admin/dashboard_controller_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe Spud::Admin::DashboardController do
+  before(:all) do
+		Spud::Core.configure do |config|
+		  config.admin_applications = [
+        {name: "Blog", thumbnail: "/url/to/image", url: "/url/to/app", order: 0},
+        {name: "Settings", thumbnail: "/url/to/image", url: "/url/to/app", order: 0},
+        {name: "Pages", thumbnail: "/url/to/image", url: "/url/to/app", order: 0}
+      ]
+		end
+  end
+
+  before(:each) do
+    activate_authlogic
+    @user = FactoryGirl.create(:spud_user)
+    SpudUserSession.create(@user)
+  end
+
+  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.spud_admin_permissions.build(FactoryGirl.attributes_for(:spud_admin_permission, :name => "Blog", :access => true))
+      @user.spud_admin_permissions.build(FactoryGirl.attributes_for(:spud_admin_permission, :name => "Pages", :access => true))
+      @user.save
+      get :index
+
+      assigns(:admin_applications).collect{|app| app[:name] }.should =~ @user.spud_admin_permissions.collect{|permission| permission.name }
+    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
+      @user.super_admin = false
+      @user.spud_admin_permissions.build(FactoryGirl.attributes_for(:spud_admin_permission, :name => "Blog", :access => true))
+      @user.spud_admin_permissions.build(FactoryGirl.attributes_for(:spud_admin_permission, :name => "Pages", :access => true))
+      @user.save
+      get :index
+
+      assigns(:admin_applications).collect{|app| app[:name] }.should_not include(:settings)
+    end
+
+    it "should display all the applications despite the users permissions given the current user is a super admin" do
+      @user.super_admin = true
+      @user.spud_admin_permissions.build(FactoryGirl.attributes_for(:spud_admin_permission, :name => "Blog", :access => true))
+      @user.save
+      get :index
+
+      assigns(:admin_applications).collect{|app| app[:name] }.should =~ Spud::Core.admin_applications.collect{|app| app[:name] }
+    end
+
+    it "should display applications in order of user preference if available" do
+      @user.super_admin = true
+      @user.save
+      @user.spud_user_settings.create(:key => "app_order",:value => "Pages,Settings")
+      get :index
+
+      assigns(:admin_applications).collect{|app| app[:name] }.should =~ ["Pages","Settings","Blog"]
+
+    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.spud_admin_permissions.build(FactoryGirl.attributes_for(:spud_admin_permission, :name => "Blog", :access => 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
+          # Spud::Core.stubs(:multisite_config).returns([{:site_id => 1}])
+        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
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+require 'spec_helper'
+
+describe Spud::Admin::UsersController do
+  before(:each) do
+    activate_authlogic
+    @user = SpudUserSession.create(FactoryGirl.build(:spud_user, :super_admin => true))
+  end
+  
+  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
+    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
+    end
+    
+    it "should not allow access to users with NO permissions" do
+      SpudUserSession.create(FactoryGirl.build(:spud_user, :super_admin => false))
+      get :index
+      
+      response.should redirect_to(root_url)   
+    end
+    
+    it "should allow access to users with the correct permissions" do
+      u = FactoryGirl.create(:spud_user, :super_admin => false)
+      u.spud_admin_permissions << FactoryGirl.build(:spud_admin_permission, :name => "Users", :access => true)
+      SpudUserSession.create(u)
+      get :index
+      
+      response.should be_success
+    end
+
+    it "should not allow access to users without permission and redirect to root_url if the user has no permissions" do
+      u = FactoryGirl.create(:spud_user, :super_admin => false)
+      u.spud_admin_permissions << []
+      SpudUserSession.create(u)
+      get :index
+      
+      response.should redirect_to(root_url)
+    end
+
+    it "should not allow access to users without permission and redirect to root_url if the users has no other admin modules" do
+      u = FactoryGirl.create(:spud_user, :super_admin => false)
+      u.spud_admin_permissions << [
+        FactoryGirl.build(:spud_admin_permission, :name => "Users", :access => false)
+      ]
+      SpudUserSession.create(u)
+      get :index
+      
+      response.should redirect_to(root_url)
+    end
+    
+    it "should not allow access to users without permission and redirect to admin_root if the users has other admin modules" do
+      u = FactoryGirl.create(:spud_user, :super_admin => false)
+      u.spud_admin_permissions << [
+        FactoryGirl.build(:spud_admin_permission, :name => "Users", :access => false),
+        FactoryGirl.build(:spud_admin_permission, :name => "App2", :access => true)
+      ]
+      SpudUserSession.create(u)
+      get :index
+      
+      response.should redirect_to(spud_admin_root_url)
+    end
+  end
+  
+  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
+    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
+    end
+  end
+  
+  describe :create do
+    context "HTML format" do
+      it "should create a new user with a valid form submission" do
+        lambda {
+          post :create, :spud_user => FactoryGirl.attributes_for(:spud_user)
+        }.should change(SpudUser, :count).by(1)
+        response.should be_redirect
+      end
+    
+      it "should not create a user with an invalid form entry" do
+        lambda {
+          post :create, :spud_user => FactoryGirl.attributes_for(:spud_user, :email => nil)
+        }.should_not change(SpudUser, :count)
+        flash[:error].should_not be_blank
+      end
+    end
+    
+    context "JS format" do
+      it "should create a new user with a valid form submission" do
+        lambda {
+          post :create, :spud_user => FactoryGirl.attributes_for(:spud_user), :format => :js
+        }.should change(SpudUser, :count).by(1)
+        response.should be_success
+      end
+    
+      it "should not create a user with an invalid form entry" do
+        lambda {
+          post :create, :spud_user => FactoryGirl.attributes_for(:spud_user, :email => nil), :format => :js
+        }.should_not change(SpudUser, :count)
+        response.should_not be_success
+      end
+      
+    end
+  end
+  
+  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
+      end
+      
+    end
+
+  end
+  
+  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 {
+        put :update, :id => user.id, :spud_user => user.attributes.merge!(:first_name => new_name)
+        user.reload
+      }.should change(user, :first_name).to(new_name)
+    end
+    
+    it "should redirect to the admin users 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(spud_admin_users_url)
+    end
+  end
+  
+  describe :destroy do
+    it "should destroy the user" do
+      user = FactoryGirl.create(:spud_user)
+      lambda {
+        delete :destroy, :id => user.id
+      }.should change(SpudUser, :count).by(-1)
+      response.should be_redirect
+    end
+    
+    it "should destroy the user with the wrong id" do
+      user = FactoryGirl.create(:spud_user)
+      lambda {
+        delete :destroy, :id => "23532"
+      }.should_not change(SpudUser, :count)
+      response.should be_redirect
+    end
+  end
+end

data/spec/controllers/spud/application_controller_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Spud::ApplicationController do
+
+
+end

data/spec/controllers/spud/password_reset_controller_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Spud::PasswordResetsController do
+  let(:user) { FactoryGirl.build(:spud_user, :id => 1) }
+
+  context :get do
+    describe :new do
+      it "should return success" do
+        get :new
+        response.should be_success
+      end
+    end
+
+    describe :edit 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
+          get :edit, :id => 1
+          response.should 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
+          get :edit, :id => user.id
+          response.should redirect_to(new_spud_user_session_url)
+        end
+      end
+    end
+  end
+
+  context :post 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
+          Spud::CoreMailer.expects(:forgot_password_notification).returns(stub(:deliver))
+          post :create, :email => user.email
+        end
+
+        it "should redirect to the login form" do
+          post :create, :email => user.email
+          response.should redirect_to(new_spud_user_session_url)
+        end
+      end
+
+      context "with an invalid user email address submitted" do
+        before(:each) do
+          SpudUser.stubs(:find_by_email).returns(nil)
+        end
+        it "should re-render the password reset form" do
+          post :create, :email => "invalid@email.com"
+          response.should render_template("new")
+        end
+      end
+    end
+
+    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)
+      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(new_spud_user_session_url)
+        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("edit")
+        end
+      end
+    end
+  end
+end

data/spec/controllers/spud/setup_controller_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Spud::SetupController do
+  
+  describe :index do
+    it "should be successful" do
+      get :index
+      
+      response.should be_success
+    end
+    
+    it "should have a page thumbnail" do
+      get :index
+      
+      assigns(:page_thumbnail).should_not be_blank
+    end
+    
+    it "should have a page name" do
+      get :index
+      
+      assigns(:page_name).should_not be_blank
+    end
+    
+    it "should set a flash error message when a spud user exists" do
+      SpudUser.stubs(:count).returns(1)
+      get :index
+      
+      flash[:error].should_not be_blank
+    end
+    
+    it "should redirect to the admin login form when there is already a user" do
+      SpudUser.stubs(:count).returns(1)
+      get :index
+      
+      response.should redirect_to(new_spud_user_session_url)
+    end
+    
+    it "should create a new user" do
+      lambda {
+        post :index, FactoryGirl.attributes_for(:spud_user)
+      }.should change(SpudUser, :count).by(1)
+    end
+    
+    it "should redirect to the admin login form when first admin user has been created" do
+      post :index, FactoryGirl.attributes_for(:spud_user)
+      
+      response.should redirect_to(new_spud_user_session_url)
+    end
+    
+    it "should display an error if the user is invalid" do
+      post :index, FactoryGirl.attributes_for(:spud_user, :email => nil)
+      
+      flash[:error].should_not be_blank
+    end
+  end
+end

data/spec/controllers/spud/sitemap_controllers_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Spud::SitemapsController do
+  describe :show do
+    it "should return the sitemap urls" do
+      Spud::Core.sitemap_urls = [
+        "http://www.google.com",
+        "http://www.example.com"
+      ]
+      get :show, :format => :xml
+      
+      assigns(:sitemap_urls).should == Spud::Core.sitemap_urls
+    end
+    
+    it "should only respond to an XML format" do
+      get :show
+      response.response_code.should == 406
+    end
+  end
+end

data/spec/controllers/spud/user_sessions_controller_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+describe Spud::UserSessionsController do
+  before(:each) do
+    # activate_authlogic
+    # SpudUserSession.create(FactoryGirl.build(:spud_user))
+  end
+
+  describe :new do
+  	it "should redirect to setup url if no users exist" do
+  		get :new
+		response.should redirect_to(spud_setup_url)
+  	end
+
+  	it "should render login form if users do exist" do
+  		u = FactoryGirl.create(:spud_user)
+  		u.save
+  		get :new
+		response.should be_success
+  	end
+  end
+
+  describe :create do
+  	it "should rerender form when login is invalid" do
+  		post :create
+  	  	response.should be_success
+  	end
+  	it "should redirect to root url 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(root_url)
+  	end
+  end
+
+  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(new_spud_user_session_url)
+  	end
+  	it "should redirect to previous page after logout" do
+        request.env["HTTP_REFERER"] = "/"
+        activate_authlogic
+	    SpudUserSession.create(FactoryGirl.build(:spud_user))
+	    delete :destroy
+	    response.should redirect_to("/")
+  	end
+  end
+end