browsercms 3.3.4 → 3.4.0.rc1

data/test/integration/cms/password_management_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class PasswordManagementTest < ActionController::IntegrationTest
+
+  def setup
+    given_there_is_a_cmsadmin
+    given_there_is_a_guest_group
+    given_there_is_a_sitemap
+    @group = Factory(:group, :name => "Member")
+
+    @section = Factory(:public_section, :parent => root_section, :name => "Passwords", :path => "/passwords")
+    @section.save
+
+    @user = Factory(:user, :email => "dexter@miamidade.gov")
+    @user.groups << @group
+    @user.save!
+
+    @forgot_password_page = Factory(:page, :section => @section, :name => "Forgot password", :path => "/passwords")
+    @reset_password_page = Factory(:page, :section => @section, :name => "Reset password", :path => "/passwords/reset")
+
+    @forgot_password_portlet = ForgotPasswordPortlet.create!(:name => "Forgot Password",
+                                                             :template => ForgotPasswordPortlet.default_template,
+                                                             :connect_to_page_id => @forgot_password_page.id,
+                                                             :connect_to_container => "main",
+                                                             :publish_on_save => true)
+
+    @reset_password_portlet = ResetPasswordPortlet.create!(:name => "Reset Password",
+                                                           :template => ResetPasswordPortlet.default_template,
+                                                           :connect_to_page_id => @reset_password_page.id,
+                                                           :connect_to_container => "main",
+                                                           :publish_on_save => true)
+
+    @forgot_password_page.publish!
+    @reset_password_page.publish!
+    ActionMailer::Base.deliveries = []
+  end
+
+  def test_forgot_password_will_send_email
+    get "/passwords"
+    assert_response :success
+    
+    post "/passwords", :email => Cms::User.last.email
+    assert_response :success
+    assert flash[:forgot_password][:notice]
+    assert ActionMailer::Base.deliveries.empty?
+  end
+
+  def forgot_password_should_render_a_form_with_an_email_address_to_enter
+    get "/passwords"
+    puts @response.body
+    assert_select 'input#email'
+    assert_response :success
+  end
+
+  def test_reset_password
+    test_forgot_password_will_send_email
+    token = Cms::User.last.reset_token
+    get "/passwords/reset?token=#{token}"
+    assert_response :success
+    
+    post "/passwords/reset", :token => token
+    assert_response :success
+    assert flash[:reset_password][:notice]
+  end
+
+end

data/test/integration/sitemap_performance_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class SitemapPerformanceTest < ActionController::IntegrationTest
+  include Cms::IntegrationTestHelper
+
+  def setup
+    given_a_site_exists
+  end
+
+  def test_homepage
+    r = Benchmark.measure do
+      get '/'
+    end
+    assert r.real < 1, "Should complete in under 1 sec. Was #{r.real}"
+  end
+
+  test "sitemap" do
+    # Make me work someday
+
+    #login_as_cms_admin
+    #
+    #puts Benchmark.measure do
+    #  get '/cms/sitemap'
+    #end
+  end
+end

data/test/mock_file.rb

@@ -0,0 +1,33 @@
+module Cms
+
+  # Simplified handling for creating files for writing tests around multipart uploads.
+  module MockFile
+    FILES_DIR = File.dirname(__FILE__) + '/fixtures/multipart'
+
+    # Creates a file to test uploading to a sample file.
+    def self.new_file(file_name='foo.jpg', content_type="image/jpeg")
+      Rack::Test::UploadedFile.new("#{FILES_DIR}/#{file_name}", content_type, false)
+    end
+  end
+
+  # For activating logging on the console 
+  def self.activate_logging
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+  end
+end
+
+module Extensions
+  module Rack
+    module Test
+      # Extensions to make Rack::Test::UploadedFile function like ActionDispatch::Http::UploadedFile during unit/functional tests.
+      module UploadedFile
+
+        # Attachment relies on this being there
+        def tempfile
+          @tempfile
+        end
+      end
+    end
+  end
+end
+Rack::Test::UploadedFile.send(:include, Extensions::Rack::Test::UploadedFile)

data/test/performance/browsing_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+# Profiling results for each test method are written to tmp/performance.
+class BrowsingTest < ActionDispatch::PerformanceTest
+  def test_homepage
+    get '/'
+  end
+end

data/test/support/engine_controller_hacks.rb

@@ -0,0 +1,34 @@
+module EngineControllerHacks
+  def get(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "GET")
+  end
+
+  # Executes a request simulating POST HTTP method and set/volley the response
+  def post(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "POST")
+  end
+
+  # Executes a request simulating PUT HTTP method and set/volley the response
+  def put(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "PUT")
+  end
+
+  # Executes a request simulating DELETE HTTP method and set/volley the response
+  def delete(action, parameters = nil, session = nil, flash = nil)
+    process_action(action, parameters, session, flash, "DELETE")
+  end
+
+  private
+
+  def process_action(action, parameters = nil, session = nil, flash = nil, method = "GET")
+    parameters ||= {}
+    merge = { :use_route => :cms }
+    if parameters[:use_route] == false
+      parameters.delete(:use_route)
+      merge = {}
+    end
+    process(action, parameters.merge!(merge), session, flash, method)
+  end
+end
+
+ActionController::TestCase.send(:include, EngineControllerHacks)

data/test/support/factory_helpers.rb

@@ -0,0 +1,57 @@
+
+module FactoryHelpers
+
+  def find_or_create_root_section
+    root = Cms::Section.root.first
+    unless root
+      # This constructor matches how seed data is set up.
+      root = Factory(:root_section)
+    end
+    root
+  end
+
+  def root_section
+    find_or_create_root_section
+  end
+
+  def given_there_is_a_sitemap
+    root = find_or_create_root_section
+    root.allow_groups = :all
+  end
+
+  def given_there_is_a_guest_group
+    group_type = Cms::GroupType.guest.first
+    unless group_type
+      group_type = Cms::GroupType.create!(:name => "Guest", :guest => true)
+    end
+
+    guest_group = Cms::Group.guest
+    unless guest_group
+      guest_group = Cms::Group.create!(:name => 'Guest', :code => Cms::Group::GUEST_CODE, :group_type => group_type)
+    end
+    guest_group
+  end
+  alias :given_a_guest_group_exists :given_there_is_a_guest_group
+
+  # Creates a sample uploaded JPG file with binary data.
+  def mock_file(options = {})
+    file_upload_object({:original_filename => "foo.jpg", :content_type => "image/jpeg"}.merge(options))
+  end
+
+  # Creates a TempFile attached to an uploaded file. Used to test attachments
+  def file_upload_object(options)
+    Cms::MockFile.new_file(options[:original_filename], options[:content_type])
+  end
+
+  def given_there_is_a_content_type(model_class)
+    Factory(:content_type, :name => model_class.to_s)
+  end
+
+  def create_admin_user(attrs={})
+    Factory(:cms_admin, {:login => "cmsadmin"}.merge(attrs))
+  end
+
+  def given_there_is_a_cmsadmin
+    create_admin_user
+  end
+end

data/test/support/rails_3_1_routes_hack.rb

@@ -0,0 +1,70 @@
+module Magic
+  module Rails
+    module Engine
+      ##
+      # Automatically append all of the current engine's routes to the main
+      # application's route set. This needs to be done for ALL functional tests that
+      # use engine routes, since the mounted routes don't work during tests.
+      #
+      # @param [Symbol] engine_symbol Optional; if provided, uses this symbol to
+      #   locate the engine class by name, otherwise uses the module of the calling
+      #   test case as the presumed name of the engine.
+      #
+      # @author Jason Hamilton (jhamilton@greatherorift.com)
+      # @author Matthew Ratzloff (matt@urbaninfluence.com)
+      def load_engine_routes(engine_symbol = nil)
+        if engine_symbol
+          engine_name = engine_symbol.to_s.camelize
+        else
+          # No engine provided, so presume the current engine is the one to load
+          engine_name = self.class.name.split("::").first.split("(").last
+        end
+        engine = ("#{engine_name}::Engine").constantize
+
+        # Append the routes for this module to the existing routes
+        ::Rails.application.routes.disable_clear_and_finalize = true
+        ::Rails.application.routes.clear!
+        ::Rails.application.routes_reloader.paths.each { |path| load(path) }
+        ::Rails.application.routes.draw do
+          resourced_routes = []
+
+          named_routes = engine.routes.named_routes.routes
+          unnamed_routes = engine.routes.routes - named_routes.values
+
+          engine.routes.routes.each do |route|
+            # Call the method by hand based on the symbol
+            path = "/#{engine_name.underscore}#{route.path}"
+            verb = route.verb.to_s.downcase.to_sym
+            requirements = route.requirements
+            if path_helper = named_routes.key(route)
+              requirements[:as] = path_helper
+            elsif route.requirements[:controller].present?
+              # Presume that all controllers referenced in routes should also be
+              # resources and append that routing on the end so that *_path helpers
+              # will still work
+              resourced_routes << route.requirements[:controller].gsub("#{engine_name.downcase}/", "").to_sym
+            end
+            send(verb, path, requirements) if respond_to?(verb)
+          end
+
+          # Add each route, once, to the end under a scope to trick path helpers.
+          # This will probably break as soon as there is route name overlap, but
+          # we'll cross that bridge when we get to it.
+          resourced_routes.uniq!
+          scope engine_name.downcase do
+            resourced_routes.each do |resource|
+              resources resource
+            end
+          end
+        end
+
+        # Finalize the routes
+        ::Rails.application.routes.finalize!
+        ::Rails.application.routes.disable_clear_and_finalize = false
+      end
+    end
+  end
+end
+
+
+Rails::Engine.send(:include, Magic::Rails::Engine)

data/test/test_helper.rb

@@ -0,0 +1,199 @@
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb", __FILE__)
+require "rails/test_help"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+require 'action_view/test_case'
+
+# Allows Generators to be unit tested
+require "rails/generators/test_case"
+
+# I'm not sure why ANY of these FactoryGirl requires are necessary at all.
+require 'factory_girl'
+require 'factories'
+
+require 'mock_file'
+require 'support/factory_helpers'
+require 'support/engine_controller_hacks'
+
+class ActiveSupport::TestCase
+
+  include FactoryHelpers
+
+  # Add more helper methods to be used by all tests here...
+  require File.dirname(__FILE__) + '/test_logging'
+  include TestLogging
+  require File.dirname(__FILE__) + '/custom_assertions'
+  include CustomAssertions
+
+  #----- Test Macros -----------------------------------------------------------
+  class << self
+    def should_validate_presence_of(options)
+      factory_name = options.keys.first
+      fields = options[factory_name]
+      fields.each do |f|
+        define_method("test_validates_presence_of_#{f}") do
+          model = Factory.build(factory_name, f => nil)
+          assert !model.valid?
+          assert_has_error_on model, f, "can't be blank"
+        end
+      end
+    end
+
+    def should_validate_uniqueness_of(options)
+      class_name = options.keys.first
+      fields = options[class_name]
+      fields.each do |f|
+        define_method("test_validates_uniqueness_of_#{f}") do
+          existing_model = Factory(class_name)
+          model = Factory.build(class_name, f => existing_model.send(f))
+          assert !model.valid?
+          assert_has_error_on model, f, "has already been taken"
+        end
+      end
+    end
+  end
+
+  def self.subclasses_from_module(module_name)
+    subclasses = []
+    mod = module_name.constantize
+    if mod.class == Module
+      mod.constants.each do |module_const_name|
+        begin
+          klass_name = "#{module_name}::#{module_const_name}"
+          klass = klass_name.constantize
+          if klass.class == Class
+            subclasses << klass
+            subclasses += klass.send(:descendants).collect { |x| x.respond_to?(:constantize) ? x.constantize : x }
+          else
+            subclasses += subclasses_from_module(klass_name)
+          end
+        rescue NameError
+          raise $!
+          puts $!.inspect
+        end
+      end
+    end
+    return subclasses
+  end
+
+  #----- Fixture/Data related helpers ------------------------------------------
+
+  def admin_user
+    cms_users(:user_1)
+  end
+
+  def create_or_find_permission_named(name)
+    Cms::Permission.named(name).first || Factory(:permission, :name => name)
+  end
+
+  def guest_group
+    Cms::Group.guest || Factory(:group, :code => Group::GUEST_CODE)
+  end
+
+  def login_as(user)
+    @request.session[:user_id] = user ? user.id : nil
+  end
+
+  def login_as_cms_admin
+    given_there_is_a_cmsadmin if Cms::User.count == 0
+    admin = Cms::User.first
+    login_as(admin)
+    admin
+  end
+
+
+  # Takes a list of the names of instance variables to "reset"
+  # Each instance variable will be set to a new instance
+  # That is found by looking that object by id
+  def reset(*args)
+    args.each do |v|
+      val = instance_variable_get("@#{v}")
+      instance_variable_set("@#{v}", val.class.find(val.id))
+    end
+  end
+
+  # @3.4.x-merge Remove me once Cucumber coverage is added
+
+  # Fixtures add incorrect Section/Section node data. We don't want to replace fixtures AGAIN (this is handled in CMS 3.3)
+  # so we can just clean it out using this method where needed to avoid test breakage.
+  def remove_all_sitemap_fixtures_to_avoid_bugs
+    #Section.delete_all
+    #SectionNode.delete_all
+    #Page.delete_all
+  end
+
+  # @3.4.x-merge Remove me once Cucumber coverage is added
+
+  # Create a 'faux' sitemap which will work for tests (avoids need for fixtures)
+  def given_a_site_exists
+    @root = root_section
+    @homepage = Factory(:public_page, :name => "Home", :section => @root, :path => "/")
+    @system_section = Factory(:public_section, :name => "System", :parent => @root, :path => "/system")
+    @not_found_page = Factory(:public_page, :name => "Not Found", :section => @system_section, :path => Cms::ErrorPages::NOT_FOUND_PATH)
+    @access_denied_page = Factory(:public_page, :name => "Access Denied", :section => @system_section, :path => Cms::ErrorPages::FORBIDDEN_PATH)
+    @error_page = Factory(:public_page, :name => "Server Error", :section => @system_section, :path => Cms::ErrorPages::SERVER_ERROR_PATH)
+  end
+end
+
+ActionController::IntegrationTest.fixture_path = ActiveSupport::TestCase.fixture_path
+
+# This might be removable in later versions of Rails 3.1.x which correctly add the routes to functional controllers
+require 'support/rails_3_1_routes_hack'
+Cms::Engine.load_engine_routes
+
+module Cms::ControllerTestHelper
+  def self.included(test_case)
+    test_case.send(:include, Cms::PathHelper)
+  end
+
+  def request
+    @request
+  end
+
+  def streaming_file_contents
+    #The body of a streaming response is a proc
+    streamer = @response.body
+#    assert_equal Proc, streamer.class
+
+#Create a dummy object for the proc to write to
+    output = Object.new
+
+    def output.write(contents)
+      (@contents ||= "") << contents
+    end
+
+    #run the proc
+    streamer.call(@response, output)
+
+    #return what it wrote to the dummy object
+    output.instance_variable_get("@contents")
+  end
+end
+
+module Cms::IntegrationTestHelper
+  def login_as(user, password = "password")
+    get login_url
+    assert_response :success
+    post login_url, :login => user.login, :password => password
+    assert_response :redirect
+    assert flash[:notice]
+  end
+
+  def login_as_cms_admin
+    login_as(Cms::User.first, "cmsadmin")
+  end
+end
+
+def create_testing_table(name)
+  ActiveRecord::Base.connection.instance_eval do
+    drop_table(name) if table_exists?(name)
+    create_table(name)
+  end
+end
+