browsercms 3.4.2 → 3.5.0.rc1

data/test/integration/sitemap_performance_test.rb

@@ -1,26 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,57 +0,0 @@
-
-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

@@ -1,70 +0,0 @@
-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

@@ -1,199 +0,0 @@
-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
-

data/test/test_logging.rb

@@ -1,67 +0,0 @@
-module TestLogging
-  def log(msg)
-    Rails.logger.info(msg)
-  end
-  
-  def log_array(obj, *columns)
-    lengths = columns.map{|m| m.to_s.length }
-
-    obj.each do |r|
-      columns.each_with_index do |m, i|
-        v = r.send(m)
-        if v.to_s.length > lengths[i]
-          lengths[i] = v.to_s.length
-        end
-      end
-    end
-
-    str = "  "
-    columns.each_with_index do |m, i|
-      str << "%#{lengths[i]}s" % m
-      str << "  "
-    end
-    str << "\n  "
-
-    columns.each_with_index do |m, i|
-      str << ("-"*lengths[i])
-      str << "  "
-    end
-    str << "\n  "
-
-    obj.each do |r|
-      columns.each_with_index do |m, i|
-        str << "%#{lengths[i]}s" % r.send(m)
-        str << "  "
-      end
-      str << "\n  "      
-    end
-
-    log str    
-  end  
-  
-  def log_table(cls, options={})
-    if options[:include_columns]
-      columns = options[:include_columns]
-    elsif options[:exclude_columns]
-      columns = cls.column_names - options[:exclude_columns].map(&:to_s)
-    else
-      columns = cls.column_names      
-    end
-    log_array (cls.uses_soft_delete? ? cls.find_with_deleted(:all) : cls.all), *columns
-  end
-  
-  def log_table_with(cls, *columns)
-    log_table(cls, :include_columns => columns)
-  end
-  
-  def log_table_without(cls, *columns)
-    log_table(cls, :exclude_columns => columns)
-  end
-
-  def log_table_without_stamps(cls, *columns)
-    log_table(cls, :exclude_columns => %w[created_at updated_at created_by_id updated_by_id] + columns)
-  end    
-  
-  extend self
-  
-end