adva 0.0.1

data/adva_cms/test/plugins/adva_url_history/section_test.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper' )
+
+if ActionController::Base.respond_to?(:tracks_url_history)
+  module IntegrationTests
+    module UrlHistoryTests
+      class SectionTest < ActionController::IntegrationTest
+        def setup
+          super
+          @section = Page.find_by_title 'a page'
+          @another_section = Page.find_by_title 'another page'
+          @site = @section.site
+          use_site! @site
+        end
+      
+        unless ApplicationController.tracks_url_history?
+          test "without url_history: Admin views page, edits the permalink and gets 404" do
+            visit '/another-page'
+            login_as_admin
+            revise_the_page_permalink
+            visit '/another-page'
+            assert_status 404
+          end
+        end
+
+        if ApplicationController.tracks_url_history?
+          test "with url_history: Admin views page, edits the permalink and gets redirected" do
+            visit '/another-page'
+            assert_status 200
+            request.url.should =~ %r(/another-page)
+            UrlHistory::Entry.recent_by_url(request.url).should_not be_nil
+
+            login_as_admin
+            revise_the_page_permalink
+            visit '/another-page'
+            assert_status 200
+            request.url.should =~ %r(/another-page-updated-permalink)
+          end
+        end
+    
+        def revise_the_page_permalink
+          visit "/admin/sites/#{@site.id}/sections/#{@another_section.id}/edit"
+          fill_in 'section[permalink]', :with => 'another-page-updated-permalink'
+          click_button 'Save'
+          request.url.should =~ %r(/admin/sites/\d+/sections)
+        end
+      end
+    end
+  end
+end

data/adva_cms/test/test_helper.rb

@@ -0,0 +1,75 @@
+defined?(TEST_HELPER_LOADED) ? raise("can not load #{__FILE__} twice") : TEST_HELPER_LOADED = true
+
+def rails_root
+  dir = File.expand_path(File.dirname(__FILE__) + "/../..")
+  while dir = File.dirname(dir) and dir != '/' do
+    return dir if File.exists?("#{dir}/config/environment.rb")
+  end
+end
+
+ENV["RAILS_ENV"] = "test"
+dir = File.dirname(__FILE__)
+require "#{rails_root}/config/environment.rb"
+
+require 'matchy'
+require 'test_help'
+require 'action_view/test_case'
+require 'with'
+require 'with-sugar'
+
+require 'globalize/i18n/missing_translations_raise_handler'
+I18n.exception_handler = :missing_translations_raise_handler
+
+class ActiveSupport::TestCase
+  include RR::Adapters::TestUnit
+
+  setup :start_db_transaction!
+  setup :setup_page_caching!
+  setup :set_locale!
+  setup :ensure_single_site_mode!
+
+  teardown :rollback_db_transaction!
+  teardown :clear_cache_dir!
+  teardown :rollback_multi_site_mode!
+  
+  setup do
+    @default_permissions = Rbac::Context.default_permissions.dup
+  end
+
+  teardown do
+    Rbac::Context.default_permissions = @default_permissions
+  end
+  
+  
+  def set_locale!
+    I18n.locale = nil
+    I18n.default_locale = :en
+  end
+
+  def stub_paperclip_post_processing!
+    stub.proxy(Paperclip::Attachment).new { |attachment| stub(attachment).post_process }
+  end
+end
+
+# include this line to test adva-cms with url_history installed
+# require dir + '/plugins/url_history/init_url_history'
+
+# reset locales in case client apps set them in the environment
+I18n.default_locale = :en
+I18n.locale = nil
+
+require_all dir + "/contexts.rb",
+            dir + "/test_helper/**/*.rb"
+require_all dir + "/../../*/test/contexts.rb",
+            dir + "/../../*/test/test_helper/**/*.rb"
+
+if DO_PREPARE_DATABASE
+  puts 'Preparing the database ...'
+  # load "#{Rails.root}/db/schema.rb"
+  require_all dir + "/fixtures.rb"
+  require_all dir + "/../../*/test/fixtures.rb"
+  
+  ActiveSupport::TestCase.setup :clear_tmp_dir!
+end
+
+require "#{Rails.root}/test/test_helper.rb" if File.exists?("#{Rails.root}/test/test_helper.rb")

data/adva_cms/test/test_helper/clear_directories.rb

@@ -0,0 +1,16 @@
+class Test::Unit::TestCase
+  def setup_page_caching!
+    ActionController::Base.page_cache_directory = Rails.root + '/tmp/cache'
+    ActionController::Base.perform_caching = true
+  end
+  
+  def clear_cache_dir!
+    cache_dir = ActionController::Base.page_cache_directory
+    FileUtils.rm_r(cache_dir) if File.exists?(cache_dir)
+  end
+  
+  def clear_tmp_dir!
+    tmp_dir = Rails.root + '/tmp/sites'
+    FileUtils.rm_r(tmp_dir) if File.exists?(tmp_dir)
+  end
+end

data/adva_cms/test/test_helper/ensure_single_site_mode.rb

@@ -0,0 +1,10 @@
+class Test::Unit::TestCase
+  def ensure_single_site_mode!
+    @old_multi_sites_enabled = Site.multi_sites_enabled
+    Site.multi_sites_enabled = false
+  end
+
+  def rollback_multi_site_mode!
+    Site.multi_sites_enabled = @old_multi_sites_enabled
+  end
+end

data/adva_cms/test/test_helper/extensions/cacheable_flash.rb

@@ -0,0 +1,14 @@
+# http://github.com/pivotal/cacheable-flash
+
+# modified the original helper to unescape stuff
+module CacheableFlash
+  module TestHelpers
+    def flash_cookie
+      return {} unless cookies['flash']
+      flash = CGI::unescape cookies['flash']
+      flash = flash ? JSON.parse(flash) : {}
+      HashWithIndifferentAccess.new flash
+    end
+  end
+end
+ActionController::TestResponse.send :include, CacheableFlash::TestHelpers

data/adva_cms/test/test_helper/extensions/cronjob.rb

@@ -0,0 +1,11 @@
+# Removes all cronjobs created by test
+#
+# after do
+#   remove_all_test_cronjobs
+# end
+#
+def remove_all_test_cronjobs
+  CronEdit::Crontab.List.keys.each do |key|
+    CronEdit::Crontab.Remove(key) if key =~ /test-/
+  end
+end

data/adva_cms/test/test_helper/extensions/even_test_log.rb

@@ -0,0 +1,21 @@
+# class Event
+#   module TestLog
+#     Event.observers << self
+#     @@events = []
+# 
+#     class << self
+#       def clear!
+#         @@events = []
+#       end
+# 
+#       def was_triggered?(type)
+#         @@events.include? type
+#       end
+# 
+#       def handle_event!(event)
+#         @@events ||= []
+#         @@events << event.type
+#       end
+#     end
+#   end
+# end

data/adva_cms/test/test_helper/extensions/integration_test.rb

@@ -0,0 +1,78 @@
+module ActionController
+  class IntegrationTest
+    def default_theme?
+      controller.site.themes.active.empty?
+    end
+
+    def displays_article(article)
+      has_tag '.entry', :text => /#{article.title}/
+    end
+
+    def does_not_display_article(article)
+      has_tag '.entry', :text => /#{article.title}/, :count => 0
+    end
+
+    def displays_comments(comments)
+      comments.each do |comment|
+        has_tag ".comment", :text => /#{comment.body}/
+      end
+    end
+
+    def renders_template(template)
+      assert_template template
+      assert_response :success
+    end
+
+    # Testing cookie based flash message.
+    #
+    # Example usage:
+    #   renders_flash 'It was successfully updated!'
+    #
+    def renders_flash(message)
+      regexp = Regexp.new(message.gsub(' ', '\\\+'))
+      assert cookies['flash'] =~ regexp,
+        "Flash message does NOT MATCH: #{message}\n" +
+        "  We got flash cookie: #{cookies['flash']}\n  what doesn't match to our test regexp: #{regexp}"
+      cookies.delete :flash
+    end
+    alias :assert_flash :renders_flash
+
+    def use_site!(site)
+      site = Site.find_by_name(site) unless site.is_a?(Site)
+      site.tap do |site|
+        @integration_session ||= open_session
+        @integration_session.host! site.host
+      end
+    end
+
+    def login_as_user
+      raise "need to set the current site before loggin in" unless @integration_session
+      post "/session", :user => {:email => 'a-user@example.com', :password => 'a password'}
+      assert controller.authenticated?
+      controller.current_user
+    end
+
+    def login_as_admin
+      raise "need to set the current site before loggin in" unless @integration_session
+      post "/session", :user => {:email => 'an-admin@example.com', :password => 'a password'}
+      assert controller.authenticated?
+      assert controller.current_user.has_role?(:admin, controller.site)
+    end
+
+    def login_as_designer
+      raise "need to set the current site before loggin in" unless @integration_session
+      post "/session", :user => {:email => 'a-designer@example.com', :password => 'a password'}
+      assert controller.authenticated?
+      puts controller.current_user.roles.inspect
+      assert controller.current_user.has_role?(:designer, controller.site)
+    end
+
+    def login_as_superuser
+      raise "need to set the current site before loggin in" unless @integration_session
+      post "/session", :user => {:email => 'a-superuser@example.com', :password => 'a password'}
+      assert controller.authenticated?
+      assert controller.current_user.has_role?(:superuser)
+    end
+
+  end
+end

data/adva_cms/test/test_helper/extensions/matchy.rb

@@ -0,0 +1,365 @@
+module Matchy
+  module Expectations
+    class Base
+      # overwritten to take options, too
+      def initialize(expected, test_case, options = {})
+        @expected = expected
+        @test_case = test_case
+        @options = options
+      end
+    end
+
+    module TestCaseExtensions
+      def be_nil
+        Matchy::Expectations::Be.new(nil, self)
+      end
+
+      def be_true
+        Matchy::Expectations::Be.new(true, self)
+      end
+
+      def be_false
+        Matchy::Expectations::Be.new(false, self)
+      end
+
+      def be_instance_of(expected)
+        Matchy::Expectations::BeInstanceOf.new(expected, self)
+      end
+
+      # def be_kind_of(expected)
+      #   Matchy::Expectations::BeKindOf.new(expected, self)
+      # end
+
+      def be_empty
+        Matchy::Expectations::BeEmpty.new(nil, self)
+      end
+
+      def be_blank
+        Matchy::Expectations::BeBlank.new(nil, self)
+      end
+
+      def be_valid
+        Matchy::Expectations::BeValid.new(nil, self)
+      end
+
+      def be_file
+        Matchy::Expectations::BeFile.new(nil, self)
+      end
+
+      def be_directory
+        Matchy::Expectations::BeDirectory.new(nil, self)
+      end
+
+      def have_tracking_enabled
+        Matchy::Expectations::HaveTrackingEnabled.new(nil, self)
+      end
+
+      # def respond_to(expected)
+      #   Matchy::Expectations::RespondTo.new(expected, self)
+      # end
+
+      def validate_presence_of(attribute, options = {})
+        Matchy::Expectations::ValidatePresenceOf.new(attribute, self, options)
+      end
+
+      def validate_uniqueness_of(attribute, options = {})
+        Matchy::Expectations::ValidateUniquenessOf.new(attribute, self, options)
+      end
+
+      def validate_length_of(attribute, options = {})
+        Matchy::Expectations::ValidateLengthOf.new(attribute, self, options)
+      end
+
+      def belong_to(expected, options = {})
+        Matchy::Expectations::Association.new(self, :belongs_to, expected, options)
+      end
+
+      def have_one(expected, options = {})
+        Matchy::Expectations::Association.new(self, :has_one, expected, options)
+      end
+
+      def have_many(expected, options = {})
+        Matchy::Expectations::Association.new(self, :has_many, expected, options)
+      end
+
+      def have_tag(*args, &block)
+        Matchy::Expectations::AssertSelect.new(:assert_select, self, *args, &block)
+      end
+
+      def be_child_of(parent)
+        Matchy::Expectations::BeChildOf.new(parent, self)
+      end
+
+      def be_a(klass)
+        Matchy::Expectations::BeA.new(klass, self)
+      end
+      alias be_an be_a
+
+      def be_frozen
+        Matchy::Expectations::BeFrozen.new(nil, self)
+      end
+
+      def be_new_record
+        Matchy::Expectations::BeNewRecord.new(nil, self)
+      end
+    end
+
+    class << self
+      def matcher(name, failure_message, negative_failure_message, &block)
+        matcher = Class.new(Base) do
+          define_method :matches?, &block
+
+          define_method :failure_message do
+            failure_message % [@receiver.inspect, @expected.inspect, @options.inspect]
+          end
+
+          define_method :negative_failure_message do
+            negative_failure_message % [@receiver.inspect, @expected.inspect, @options.inspect]
+          end
+        end
+        const_set(name, matcher)
+      end
+    end
+
+    matcher "Be",
+            "Expected %s to be %s.",
+            "Expected %s not to be %s." do |receiver|
+      @receiver = receiver
+      @expected.class === receiver
+    end
+
+    matcher "BeInstanceOf",
+            "Expected %s to be an instance of %s.",
+            "Expected %s not to be an instance of %s." do |receiver|
+      @receiver = receiver
+      receiver.instance_of? @expected
+    end
+
+    # matcher "BeKindOf",
+    #         "Expected %s to be a kind of %s.",
+    #         "Expected %s not to be a kind of %s." do |receiver|
+    #   @receiver = receiver
+    #   receiver.kind_of? @expected
+    # end
+
+    matcher "BeEmpty",
+            "Expected %s to be empty.",
+            "Expected %s not to be empty." do |receiver|
+      @receiver = receiver
+      receiver.empty?
+    end
+
+    matcher "BeBlank",
+            "Expected %s to be blank.",
+            "Expected %s not to be blank." do |receiver|
+      @receiver = receiver
+      receiver.blank?
+    end
+
+    matcher "BeValid",
+            "Expected %s to be valid.",
+            "Expected %s not to be valid." do |receiver|
+      @receiver = receiver
+      receiver.valid?
+    end
+
+    matcher "BeFile",
+            "Expected the file %s to exist.",
+            "Expected the file %s not to exist." do |receiver|
+      @receiver = receiver
+      File.file?(receiver)
+    end
+
+    matcher "BeDirectory",
+            "Expected the directory %s to exist.",
+            "Expected the directory %s not to exist." do |receiver|
+      @receiver = receiver
+      File.directory?(receiver)
+    end
+
+    matcher "HaveTrackingEnabled",
+            "Expected %s to have tracking enabled.",
+            "Expected %s to not have tracking enabled." do |receiver|
+      @receiver = receiver
+      receiver.tracking_enabled?
+    end
+
+    # matcher "RespondTo",
+    #         "Expected %s to respond to %s.",
+    #         "Expected %s not to respond to %s." do |receiver|
+    #   @receiver = receiver
+    #   receiver.respond_to? @expected
+    # end
+
+    matcher "ValidatePresenceOf",
+            "Expected %s to validate the presence of %s.",
+            "Expected %s not to validate the presence of %s." do |receiver|
+      receiver = receiver.new if receiver.is_a?(Class)
+      @receiver = receiver
+
+      # stubs the method given as @options[:if] on the receiver
+      RR.stub(receiver).__creator__.create(@options[:if]).returns(true) if @options[:if]
+
+      receiver.send("#{@expected}=", nil)
+      !receiver.valid? && receiver.errors.invalid?(@expected)
+    end
+
+    matcher "ValidateLengthOf",
+            "Expected %s to validate the length of %s (with %s).",
+            "Expected %s not to validate the length of %s (with %s)." do |receiver|
+      receiver = receiver.new if receiver.is_a?(Class)
+      @receiver = receiver
+
+      max = @options[:within] || @options[:is]
+      max = max.last if max.respond_to?(:last)
+
+      value = receiver.send(@expected).to_s
+      value = 'x' if value.blank?
+      value = (value * (max  + 1))[0, max + 1]
+
+      receiver.send("#{@expected}=", value)
+      !receiver.valid? && receiver.errors.invalid?(@expected)
+    end
+
+
+    matcher "BeChildOf",
+            "Expected %s to be a child of %s.",
+            "Expected %s not to be a child of %s." do |receiver|
+      @receiver = receiver
+      @receiver.parent == @expected
+    end
+
+    matcher "BeA",
+            "Expected %s to be a(n) %s.",
+            "Expected %s not to be a(n) %s." do |receiver|
+      @receiver = receiver
+      @receiver.is_a?(@expected)
+    end
+
+    matcher "BeFrozen",
+            "Expected %s to be frozen.",
+            "Expected %s not to be frozen." do |receiver|
+      @receiver = receiver
+      @receiver.frozen?
+    end
+
+    matcher "BeNewRecord",
+            "Expected %s to be a new record.",
+            "Expected %s not to be a new record." do |receiver|
+      @receiver = receiver
+      @receiver.new_record?
+    end
+
+    class ValidateUniquenessOf < Base
+      def matches?(model)
+        RR.reset
+        @receiver = model
+        scopes = Array(@options[:scope])
+        args = !scopes.empty? ? RR.satisfy { |args| scopes.each { |scope| args.first =~ /.#{scope} (=|IS) \?/ } } : RR.anything
+
+        class_hierarchy = [model.class]
+        while class_hierarchy.first != ActiveRecord::Base
+          class_hierarchy.unshift(class_hierarchy.first.superclass)
+        end
+        finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
+
+        RR.mock(finder_class).exists?.with(args).returns true
+        !model.valid? && model.errors.invalid?(@expected)
+        RR.verify
+        true
+      rescue RR::Errors::RRError => e
+        false
+      end
+
+      def failure_message
+        "Expected #{@receiver.class.name} to validate the uniqueness of #{@expected.inspect}" +
+        (@options[:scope] ? " with scope #{@options[:scope].inspect}." : '.')
+      end
+
+      def negative_failure_message
+        "Expected #{@receiver.class.name} not to validate the uniqueness of #{@expected.inspect}" +
+        (@options[:scope] ? " with scope #{@options[:scope].inspect}." : '.')
+      end
+    end
+
+    class Association < Base
+      def initialize(test_case, type, expected, options = {})
+        @type = type
+        @options = options
+        super expected, test_case
+      end
+
+      def matches?(model)
+        @receiver = model
+        model = model.class if model.is_a? ActiveRecord::Base
+        !!model.reflect_on_all_associations(@type).find do |a|
+          a.name == @expected and options_match?(a.options)
+        end
+      end
+
+      def options_match?(options)
+        @options.each do |key, value|
+          return false if !options.has_key?(key) || options[key] != value
+        end
+        true
+      end
+
+      def failure_message
+        "Expected #{@receiver.class.name} to #{@type} #{@expected.inspect}."
+      end
+
+      def negative_failure_message
+        "Expected #{@receiver.class.name} not to #{@type} #{@expected.inspect}."
+      end
+    end
+
+      class AssertSelect < Base
+        def initialize(assertion, test_case, *args, &block)
+          super nil, test_case
+          @assertion = assertion
+          @args = args
+          @block = block
+        end
+
+        def matches?(response_or_text, &block)
+          if ActionController::TestResponse === response_or_text and
+                   response_or_text.headers.key?('Content-Type') and
+                   !response_or_text.headers['Content-Type'].blank? and
+                   response_or_text.headers['Content-Type'].to_sym == :xml
+            @args.unshift(HTML::Document.new(response_or_text.body, false, true).root)
+          elsif String === response_or_text
+            @args.unshift(HTML::Document.new(response_or_text).root)
+          end
+          @block = block if block
+          begin
+            @test_case.send(@assertion, *@args, &@block)
+          rescue ::Test::Unit::AssertionFailedError => @error
+          end
+
+          @error.nil?
+        end
+
+        def failure_message; @error.message; end
+        def negative_failure_message; "should not #{description}, but did"; end
+
+        def description
+          case @assertion
+            when :assert_select       then "have tag#{format_args(*@args)}"
+            when :assert_select_email then "send email#{format_args(*@args)}"
+          end
+        end
+
+        protected
+          def format_args(*args)
+            return "" if args.empty?
+            return "(#{arg_list(*args)})"
+          end
+
+          def arg_list(*args)
+            args.collect do |arg|
+              arg.respond_to?(:description) ? arg.description : arg.inspect
+            end.join(", ")
+          end
+      end
+  end
+end