tb_cms 1.2.0.beta1 → 1.2.0.beta3

data/spec/controllers/admin/menu_items_controller_spec.rb

@@ -1,146 +1,115 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::MenuItemsController do
+describe Admin::MenuItemsController, :type => :controller do
   before(:each) do
     activate_authlogic
     u = SpudUser.new(:login => "testuser",:email => "test@testuser.com",:password => "test",:password_confirmation => "test")
     u.super_admin = true
     u.save
     @user = SpudUserSession.create(u)
-    Spud::Core.configure do |config|
-        config.site_name = "Test Site"
-        config.multisite_mode_enabled = false
-        config.multisite_config = []
-    end
-
     @menu = FactoryGirl.create(:spud_menu)
   end
 
 
-  describe :index do
+  describe 'index' do
     it "should return an array of menus" do
       2.times {|x|  s = FactoryGirl.create(:spud_menu_item,:spud_menu_id => @menu.id,:parent_id => @menu.id)}
       get :index,:menu_id =>@menu.id
 
-      assigns(:menu_items).count.should be > 1
+      expect(assigns(:menu_items).count).to be > 1
     end
     it "should redirect if the menu is not found" do
       get :index,:menu_id => @menu.id + 1
-      response.should redirect_to admin_menus_url
-      flash[:error].should_not be_blank
+      expect(response).to redirect_to admin_menus_url
     end
   end
 
-  describe :new do
+  describe 'new' do
     it "should assign a new menu" do
       get :new,:menu_id =>@menu.id
-      assigns(:menu_item).should_not be_blank
-      response.should be_success
+      expect(assigns(:menu_item)).to_not be_blank
+      expect(response).to be_success
     end
   end
 
-  describe :create do
+  describe 'create' do
     it "should create a new menu item with a valid form submission" do
-      lambda {
+      expect {
         post :create,:menu_id => @menu.id, :spud_menu_item => FactoryGirl.attributes_for(:spud_menu_item,:parent_id => nil).reject{|k,v| k == 'id' || k == :spud_menu_id}
-      }.should change(SpudMenuItem,:count).by(1)
-      response.should be_redirect
+      }.to change(SpudMenuItem,:count).by(1)
+      expect(response).to be_redirect
     end
 
     it "should not create a menu item with an invalid form entry" do
       yamldata = FactoryGirl.attributes_for(:spud_menu_item,:name => nil).reject{|k,v| k == 'id' || k == :spud_menu_id}
 
-      lambda {
+      expect {
         post :create,:menu_id => @menu.id, :spud_menu_item => FactoryGirl.attributes_for(:spud_menu_item,:name => nil,:parent_id => nil).reject{|k,v| k == 'id' || k == :spud_menu_id}
-      }.should_not change(SpudMenuItem,:count)
+      }.to_not change(SpudMenuItem,:count)
     end
 
     it "should autoset order if not specified" do
       menuitem = FactoryGirl.create(:spud_menu_item,:parent_id => @menu.id)
 
       post :create,:menu_id => @menu.id, :spud_menu_item => FactoryGirl.attributes_for(:spud_menu_item,:menu_order => nil,:parent_id => nil).reject{|k,v| k == 'id' || k == :spud_menu_id}
-      assigns(:menu_item).menu_order.should == 1
+      expect(assigns(:menu_item).menu_order).to eq(1)
     end
 
     it "should assign the menu name based on page name if left blank" do
       page = FactoryGirl.create(:spud_page)
       post :create,:menu_id => @menu.id, :spud_menu_item => FactoryGirl.attributes_for(:spud_menu_item,:name => nil,:spud_page_id => page.id).reject{|k,v| k == 'id' || k == :spud_menu_id}
-      assigns(:menu_item).name.should == page.name
+      expect(assigns(:menu_item).name).to eq(page.name)
     end
 
     it "should set the parent to a submenu if specified" do
       menuitem = FactoryGirl.create(:spud_menu_item,:parent_id => @menu.id)
       post :create,:menu_id => @menu.id, :spud_menu_item => FactoryGirl.attributes_for(:spud_menu_item,:parent_id => menuitem.id).reject{|k,v| k == 'id' || k == :spud_menu_id}
-      assigns(:menu_item).parent.should == menuitem
+      expect(assigns(:menu_item).parent).to eq(menuitem)
     end
   end
 
-  describe :edit do
+  describe 'edit' do
     it "should respond with menu item by id" do
       menu1 = FactoryGirl.create(:spud_menu_item)
       menu2 = FactoryGirl.create(:spud_menu_item)
       get :edit, :menu_id => @menu.id,:id => menu2.id
-      assigns(:menu_item).should == menu2
+      expect(assigns(:menu_item)).to eq(menu2)
     end
 
     it "should redirect_to index if menu item not found" do
       get :edit,:menu_id => @menu.id,:id => "345"
-      response.should redirect_to admin_menu_menu_items_url(:menu_id => @menu.id)
+      expect(response).to redirect_to admin_menu_menu_items_url(:menu_id => @menu.id)
     end
   end
 
-  describe :update do
+  describe 'update' do
     it "should update the name when the name attribute is changed" do
       menu_item = FactoryGirl.create(:spud_menu_item)
       new_name = 'MyMenu'
-      lambda {
+      expect {
         put :update,:menu_id => @menu.id,:id => menu_item.id, :spud_menu_item => menu_item.attributes.merge!(:name => new_name,:parent_id => nil).reject{|k,v| k.to_sym == :spud_menu_id || k == 'id' || k.to_sym == :updated_at || k.to_sym == :created_at}
         menu_item.reload
-      }.should change(menu_item,:name).to(new_name)
+      }.to change(menu_item,:name).to(new_name)
     end
     it "should assign a menu to a submenu if parentid is defined" do
       menu_item1 = FactoryGirl.create(:spud_menu_item)
       menu_item = FactoryGirl.create(:spud_menu_item)
 
-      lambda {
+      expect {
         put :update,:menu_id => @menu.id,:id => menu_item.id, :spud_menu_item => menu_item.attributes.merge!(:parent_id => menu_item1.id).reject{|k,v| k.to_sym == :spud_menu_id || k == 'id' || k.to_sym == :updated_at || k.to_sym == :created_at}
         menu_item.reload
-      }.should change(menu_item,:parent).to(menu_item1)
+      }.to change(menu_item,:parent).to(menu_item1)
     end
   end
 
 
-  describe :destroy do
+  describe 'destroy' do
     it "should destroy the menu item" do
       menu_item = FactoryGirl.create(:spud_menu_item,:parent_id => @menu.id)
-      lambda {
+      expect {
         delete :destroy,:menu_id => @menu.id,:id => menu_item.id
-      }.should change(SpudMenuItem,:count).by(-1)
+      }.to change(SpudMenuItem,:count).by(-1)
     end
   end
 
-  describe :multisite 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,:short_name => "siteb"}]
-      end
-      Spud::Cms.configure do |config|
-        config.multisite_config = [{:short_name => "siteb",:default_page_parts => ["Body","Sidebar"]}]
-      end
-      session[:admin_site] = 1
-    end
-
-
-      describe :edit do
-        it "should not allow editing of a menu_item in a menu that is different from the current admin site" do
-          menu_item = FactoryGirl.create(:spud_menu_item)
-          get :edit,:id => menu_item.id,:menu_id => @menu.id
-          response.should redirect_to admin_menus_url
-          flash[:warning].should_not be_blank
-        end
-      end
-
-  end
 end

data/spec/controllers/admin/menus_controller_spec.rb

@@ -1,120 +1,98 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::MenusController do
+describe Admin::MenusController, :type => :controller do
   before(:each) do
     activate_authlogic
     u = SpudUser.new(:login => "testuser",:email => "test@testuser.com",:password => "test",:password_confirmation => "test")
     u.super_admin = true
     u.save
     @user = SpudUserSession.create(u)
-    Spud::Core.configure do |config|
-        config.site_name = "Test Site"
-        config.multisite_mode_enabled = false
-        config.multisite_config = []
-    end
   end
 
 
-  describe :index do
+  describe 'index' do
     it "should return an array of menus" do
-      2.times {|x|  s = FactoryGirl.create(:spud_menu)}
+      2.times { FactoryGirl.create(:spud_menu) }
       get :index
 
-      assigns(:menus).count.should be > 1
+      expect(assigns(:menus).count).to be > 1
     end
 
   end
 
-  describe :new do
+  describe 'new' do
     it "should response with new menu" do
       get :new
-      assigns(:menu).should_not be_blank
-      response.should be_success
+      expect(assigns(:menu)).to_not be_blank
+      expect(response).to be_success
     end
   end
 
-  describe :create do
+  describe 'create' do
     it "should create a new menu with a valid form submission" do
-      lambda {
-        post :create, :spud_menu => FactoryGirl.attributes_for(:spud_menu).reject{|k,v| k == 'site_id' || k == 'id'}
-      }.should change(SpudMenu,:count).by(1)
-      response.should be_redirect
+      expect {
+        post :create, :spud_menu => FactoryGirl.attributes_for(:spud_menu).reject{|k,v| k == 'id'}
+      }.to change(SpudMenu,:count).by(1)
+      expect(response).to be_redirect
     end
 
     it "should not create a menu with an invalid form entry" do
-      lambda {
-        post :create, :spud_menu => FactoryGirl.attributes_for(:spud_menu,:name => nil).reject{|k,v| k == 'site_id' || k == 'id'}
-      }.should_not change(SpudMenu,:count)
-
-
-    end
-  end
-
-  describe :multisite 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
+      expect {
+        post :create, :spud_menu => FactoryGirl.attributes_for(:spud_menu,:name => nil).reject{|k,v| k == 'id'}
+      }.to_not change(SpudMenu,:count)
 
-    end
-    it "should not allow editing of a menu on a different site id" do
-      menu2 = FactoryGirl.create(:spud_menu,:site_id => 1)
-      get :edit,:id => menu2.id
 
-      response.should redirect_to admin_menus_url
     end
   end
 
-  describe :edit do
+  describe 'edit' do
     it "should response with menu by id" do
       menu1 = FactoryGirl.create(:spud_menu)
       menu2 = FactoryGirl.create(:spud_menu)
       get :edit,:id => menu2.id
-      assigns(:menu).should == menu2
+      expect(assigns(:menu)).to eq(menu2)
     end
     it "should redirect to index if menu not found" do
       get :edit,:id => 3
-      response.should redirect_to admin_menus_url
+      expect(response).to redirect_to admin_menus_url
     end
 
   end
 
-  describe :update do
+  describe 'update' do
     it "should update the name when the name attribute is changed" do
       menu = FactoryGirl.create(:spud_menu)
       new_name = 'MyMenu'
-      lambda {
-        put :update,:id => menu.id, :spud_menu => menu.attributes.merge!(:name => new_name).reject{|k,v| k == 'site_id' || k == 'id'}
+      expect {
+        put :update,:id => menu.id, :spud_menu => menu.attributes.merge!(:name => new_name).reject{|k,v| k == 'id'}
         menu.reload
-      }.should change(menu,:name).to(new_name)
+      }.to change(menu,:name).to(new_name)
 
     end
 
     it "should redirect to the admin menus after a successful update" do
       menu = FactoryGirl.create(:spud_menu)
-      put :update,:id => menu.id,:spud_menu => menu.attributes.merge!(:name => "MyMenu").reject{|k,v| k == 'site_id' || k == 'id'}
+      put :update,:id => menu.id,:spud_menu => menu.attributes.merge!(:name => "MyMenu").reject{|k,v| k == 'id'}
 
-      response.should redirect_to(admin_menu_menu_items_url(:menu_id => menu.id))
+      expect(response).to redirect_to(admin_menu_menu_items_url(:menu_id => menu.id))
     end
   end
 
-  describe :destroy do
+  describe 'destroy' do
     it "should destroy the menu" do
       menu = FactoryGirl.create(:spud_menu)
-      lambda {
+      expect {
         delete :destroy, :id => menu.id
-      }.should change(SpudMenu,:count).by(-1)
-      response.should be_redirect
+      }.to change(SpudMenu,:count).by(-1)
+      expect(response).to be_redirect
     end
 
     it "should not destroy the menu with a wrong id" do
       menu = FactoryGirl.create(:spud_menu)
-      lambda {
+      expect {
         delete :destroy,:id => "23532"
-      }.should_not change(SpudMenu,:count)
-      response.should be_redirect
+      }.to_not change(SpudMenu,:count)
+      expect(response).to be_redirect
     end
 
   end

data/spec/controllers/admin/pages_controller_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::PagesController do
+describe Admin::PagesController, :type => :controller do
   before(:each) do
     activate_authlogic
     u = SpudUser.new(:login => "testuser",:email => "test@testuser.com",:password => "test",:password_confirmation => "test")
@@ -9,20 +9,12 @@ describe Admin::PagesController do
     @user = SpudUserSession.create(u)
   end
 
-  it "should return site_config by short_name" do
-    Spud::Cms.configure do |config|
-      config.multisite_config = [{:short_name => "siteb",:site_name => "Test Site B",:site_id => 2}]
-    end
-
-    Spud::Cms.site_config_for_short_name(:siteb)[:site_id].should == 2
-  end
-
-  describe :index do
+  describe 'index' do
     it "should return an array of parent pages" do
       2.times {|x|  s = FactoryGirl.create(:spud_page)}
       get :index
 
-      assigns(:pages).count.should be > 1
+      expect(assigns(:pages).count).to be > 1
     end
 
     it "should only return parent pages" do
@@ -30,89 +22,80 @@ describe Admin::PagesController do
       FactoryGirl.create(:spud_page,:spud_page_id => 1)
 
       get :index
-      assigns(:pages).count.should == 2
+      expect(assigns(:pages).count).to eq(2)
     end
   end
 
-  describe :show do
+  describe 'show' do
     it "should respond successfully" do
       p = FactoryGirl.create(:spud_page)
       get :show ,:id => p.id
-      assigns(:layout).should render_template(:layout => "layouts/#{Spud::Cms.default_page_layout}")
-      response.should be_success
+      expect(assigns(:layout)).to render_template(:layout => "layouts/#{Spud::Cms.default_page_layout}")
+      expect(response).to be_success
     end
-
-
-
-    # it "should redirect if no id specified" do
-    #   get :show,:id => nil
-
-    #   response.should redirect_to admin_pages_url
-    # end
-
   end
 
-  describe :new do
+  describe 'new' do
     it "should respond successfully" do
       get :new
 
-      response.should be_success
+      expect(response).to be_success
     end
 
     it "should build a page object for the form" do
       get :new
 
-      assigns(:page).should_not be_blank
+      expect(assigns(:page)).to_not be_blank
     end
   end
 
-  describe :edit do
+  describe 'edit' do
     context "HTML format" do
       it "should load the correct page for the edit form" do
         page = FactoryGirl.create(:spud_page)
         get :edit, :id => page.id
 
-        assigns(:page).id.should == page.id
+        expect(assigns(:page).id).to eq(page.id)
       end
     end
 
   end
 
 
-  describe :update do
+  describe 'update' do
     it "should update the name when the attribute is changed" do
       page = FactoryGirl.create(:spud_page)
       new_name = "Adam"
-      lambda {
-        put :update, :id => page.id, :spud_page => page.attributes.merge!(:name => new_name).reject{ |key,value| key == 'id' || key == 'created_at' || key == 'updated_at' || key == 'site_id'}
+      expect {
+        put :update, :id => page.id, :spud_page => page.attributes.merge!(:name => new_name).reject{ |key,value| key == 'id' || key == 'created_at' || key == 'updated_at'}
         page.reload
-      }.should change(page, :name).to(new_name)
+      }.to change(page, :name).to(new_name)
     end
 
     it "should redirect to the page root index after a successful update" do
       page = FactoryGirl.create(:spud_page)
       new_name = "Adam"
-      put :update, :id => page.id, :spud_page => page.attributes.merge!(:name => new_name).reject{ |key,value| key == 'id' || key == 'created_at' || key == 'updated_at' || key == 'site_id'}
+      put :update, :id => page.id, :spud_page => page.attributes.merge!(:name => new_name).reject{ |key,value| key == 'id' || key == 'created_at' || key == 'updated_at'}
 
-      response.should redirect_to(admin_pages_url)
+      expect(response).to redirect_to(admin_pages_url)
     end
   end
 
-  describe :destroy do
+  describe 'destroy' do
     it "should destroy the page" do
       page = FactoryGirl.create(:spud_page)
-      lambda {
+      expect {
         delete :destroy, :id => page.id
-      }.should change(SpudPage, :count).by(-1)
-      response.should be_redirect
+      }.to change(SpudPage, :count).by(-1)
+      expect(response).to be_redirect
     end
 
     it "should destroy the user with the wrong id" do
       page = FactoryGirl.create(:spud_page)
-      lambda {
+      expect {
         delete :destroy, :id => "23532"
-      }.should_not change(SpudPage, :count)
-      response.should be_redirect
+      }.to_not change(SpudPage, :count)
+      expect(response).to be_redirect
     end
   end
 

data/spec/controllers/admin/snippets_controller_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Admin::SnippetsController do
+describe Admin::SnippetsController, :type => :controller do
 
 end

data/spec/controllers/pages_controller_spec.rb

@@ -1,29 +1,20 @@
-require 'spec_helper'
+require 'rails_helper'
+
+describe PagesController, :type => :controller do
+  describe 'show' do
 
-describe PagesController do
-  describe :show do
-    before(:each) do
-      Spud::Core.configure do |config|
-        config.site_name = "Test Site"
-        config.multisite_mode_enabled = false
-        config.multisite_config = []
-      end
-      Spud::Cms.configure do |config|
-        config.cache_mode = false
-      end
-    end
     it "should render a page" do
       page = FactoryGirl.create(:spud_page)
       get :show ,:id => page.url_name
-      assigns(:layout).should render_template(:layout => "layouts/#{Spud::Cms.default_page_layout}")
-      response.should be_success
+      expect(assigns(:layout)).to render_template(:layout => "layouts/#{Spud::Cms.default_page_layout}")
+      expect(response).to be_success
     end
 
     it "should render home page if id is blank" do
       page = FactoryGirl.create(:spud_page,:name => "home")
       get :show
-      assigns(:page).should == page
-      response.should be_success
+      expect(assigns(:page)).to eq(page)
+      expect(response).to be_success
     end
 
     it "should redirect to new page url from old page url if it was changed" do
@@ -33,27 +24,15 @@ describe PagesController do
 
       get :show, :id => "about"
 
-     response.should redirect_to page_url(:id => "about-us")
+     expect(response).to redirect_to page_url(:id => "about-us")
 
     end
 
-
-
     it "should not allow access to private pages when logged out" do
       page = FactoryGirl.create(:spud_page,:name => "about",:visibility => 1)
 
       get :show, :id => "about"
-      response.should redirect_to login_path
-    end
-
-    describe "page caching" do
-      before(:each) do
-        Spud::Cms.configure do |config|
-          config.cache_mode = nil
-        end
-      end
-
-
+      expect(response).to redirect_to login_path(:return_to => '/about')
     end
 
     describe "authorized login" do
@@ -69,40 +48,9 @@ describe PagesController do
         page = FactoryGirl.create(:spud_page,:name => "about",:visibility => 1)
 
         get :show, :id => "about"
-        response.should be_success
+        expect(response).to be_success
       end
     end
 
-    describe "multisite enabled" 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 not show a page on a different site" do
-          page = FactoryGirl.create(:spud_page,:name => "about",:site_id => 0)
-          get :show,:id=>"about"
-          response.response_code.should == 404
-        end
-
-        it "should show the right page" do
-          page = FactoryGirl.create(:spud_page,:name => "about",:site_id => 0)
-          page2 = FactoryGirl.create(:spud_page,:name => "about",:site_id => 1)
-          get :show,:id=>"about"
-          assigns(:page).should == page2
-        end
-
-        it "should return the homepage of the current site" do
-          page = FactoryGirl.create(:spud_page,:name => "home",:site_id => 0)
-          page_site1 = FactoryGirl.create(:spud_page,:name => "home",:site_id => 1)
-
-          get :show
-          assigns(:page).should == page_site1
-        end
-
-    end
   end
 end

data/spec/dummy/config/application.rb

@@ -7,6 +7,11 @@ require "tb_cms"
 
 module Dummy
   class Application < Rails::Application
+
+    Spud::Core.configure do |config|
+        config.site_name = "Test Site"
+    end
+
     # Settings in config/environments/* take precedence over those specified here.
     # Application configuration should go into files in config/initializers
     # -- all .rb files in that directory are automatically loaded.

data/spec/dummy/config/environments/production.rb

@@ -9,7 +9,7 @@ Dummy::Application.configure do
   config.action_controller.perform_caching = true
 
   # Disable Rails's static asset server (Apache or nginx will already do this)
-  config.serve_static_assets = false
+  config.serve_static_files = false
 
   # Compress JavaScripts and CSS
   config.assets.compress = true

data/spec/dummy/config/environments/test.rb

@@ -8,7 +8,7 @@ Dummy::Application.configure do
   config.cache_classes = true
 
   # Configure static asset server for tests with Cache-Control for performance
-  config.serve_static_assets = true
+  config.serve_static_files = true
   config.static_cache_control = "public, max-age=3600"
 
   # Deprecated

data/spec/dummy/db/migrate/{20140110051458_create_spud_liquid_tags.tb_core.rb → 20141231214458_create_tb_liquid_spud_liquid_tags.tb_liquid.rb}

@@ -1,5 +1,5 @@
-# This migration comes from tb_core (originally 20140110040026)
-class CreateSpudLiquidTags < ActiveRecord::Migration
+# This migration comes from tb_liquid (originally 20140110142037)
+class CreateTbLiquidSpudLiquidTags < ActiveRecord::Migration
   def change
     create_table :spud_liquid_tags do |t|
       t.integer :attachment_id

data/spec/dummy/db/migrate/{20140110051483_change_liquid_tags_to_polymorphic.tb_cms.rb → 20141231214480_change_liquid_tags_to_polymorphic.tb_cms.rb}

@@ -3,9 +3,7 @@ class ChangeLiquidTagsToPolymorphic < ActiveRecord::Migration
   def up
     rename_column :spud_page_liquid_tags, :spud_page_partial_id, :attachment_id
     add_column :spud_page_liquid_tags, :attachment_type, :string
-
-    add_index :spud_page_liquid_tags, [:attachment_type,:attachment_id]
-
+    add_index :spud_page_liquid_tags, [:attachment_type, :attachment_id], :name => 'inde_spud_page_liquid_tags_on_attachment'
     if defined?(SpudPageLiquidTag)
       SpudPageLiquidTag.all.each do |f|
         f.update_attributes(:attachment_type => "SpudPagePartial")