integrity 0.1.8

data/test/helpers/acceptance/git_helper.rb

@@ -0,0 +1,99 @@
+module GitHelper
+  @@_git_repositories = Hash.new {|h,k| h[k] = Repo.new(k) }
+  
+  def git_repo(name)
+    @@_git_repositories[name]
+  end
+  
+  def destroy_all_git_repos
+    @@_git_repositories.each {|n,r| r.destroy }
+    @@_git_repositories.clear
+  end
+  
+  class Repo
+    attr_reader :path
+    
+    def initialize(name)
+      @name = name
+      @path = "/tmp" / @name.to_s
+      create
+    end
+    
+    def path
+      @path / ".git"
+    end
+    
+    def create
+      destroy
+      FileUtils.mkdir_p @path
+      
+      Dir.chdir(@path) do
+        system 'git init &>/dev/null'
+        system 'git config user.name "John Doe"'
+        system 'git config user.email "johndoe@example.org"'
+        system 'echo "just a test repo" >> README'
+        system 'git add README &>/dev/null'
+        system 'git commit -m "First commit" &>/dev/null'
+      end
+      
+      add_successful_commit
+    end
+
+    def commits
+      Dir.chdir(@path) do
+        commits = `git log --pretty=oneline`.collect { |line| line.split(" ").first }
+        commits.inject([]) do |commits, sha1|
+          format  = %Q(---%n:message: >-%n  %s%n:timestamp: %ci%n:id: #{sha1})
+          commits << YAML.load(`git show -s --pretty=format:"#{format}" #{sha1}`)
+        end
+      end
+    end
+
+    def add_commit(message, &action)
+      Dir.chdir(@path) do
+        yield action
+        system %Q(git commit -m "#{message}" &>/dev/null)
+      end
+    end
+    
+    def add_failing_commit
+      add_commit "This commit will fail" do
+        system %Q(echo '#{build_script(false)}' > test)
+        system %Q(chmod +x test)
+        system %Q(git add test &>/dev/null)
+      end
+    end
+
+    def add_successful_commit
+      add_commit "This commit will work" do
+        system %Q(echo '#{build_script(true)}' > test)
+        system %Q(chmod +x test)
+        system %Q(git add test &>/dev/null)
+      end
+    end
+    
+    def head
+      Dir.chdir(@path) do
+        `git log --pretty=format:%H | head -1`.chomp
+      end
+    end
+    
+    def short_head
+      head[0..6]
+    end
+    
+    def destroy
+      FileUtils.rm_rf @path if File.directory?(@path)
+    end
+    
+    protected
+    
+      def build_script(successful=true)
+        <<-script
+#!/bin/sh
+echo "Running tests..."
+exit #{successful ? 0 : 1}
+script
+      end
+  end
+end

data/test/helpers/acceptance/textfile_notifier.rb

@@ -0,0 +1,26 @@
+module Integrity
+  class Notifier
+    class Textfile < Notifier::Base
+      def self.to_haml
+        <<-haml
+%p.normal
+  %label{ :for => "textfile_notifier_file" } File
+  %input.text#textfile_notifier_file{ :name => "notifiers[Textfile][file]", :type => "text", :value => config["file"] }
+        haml
+      end
+      
+      def initialize(build, config={})
+        super
+        @file = @config["file"]
+      end
+      
+      def deliver!
+        File.open(@file, "a") do |f|
+          f.puts "=== #{short_message} ==="
+          f.puts
+          f.puts full_message
+        end
+      end
+    end
+  end
+end

data/test/helpers/expectations.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + "/expectations/be_a"
+require File.dirname(__FILE__) + "/expectations/change"
+require File.dirname(__FILE__) + "/expectations/have"
+require File.dirname(__FILE__) + "/expectations/predicates"
+require File.dirname(__FILE__) + "/expectations/have_tag"

data/test/helpers/expectations/be_a.rb

@@ -0,0 +1,23 @@
+module Matchy::Expectations
+  class BeAExpectation < Base
+    def matches?(receiver)
+      @receiver = receiver
+      @receiver.is_a?(@expected)
+    end
+  
+    def failure_message
+      "Expected #{@receiver.inspect} to be a #{@expected.inspect}."
+    end
+  
+    def negative_failure_message
+      "Expected #{@receiver.inspect} to not be a #{@expected.inspect}."
+    end
+  end
+  
+  module TestCaseExtensions
+    def be_a(obj)
+      Matchy::Expectations::BeAExpectation.new(obj, self)
+    end
+    alias :be_an :be_a
+  end
+end

data/test/helpers/expectations/change.rb

@@ -0,0 +1,90 @@
+module Matchy::Expectations
+  class ChangeExpectation < Base
+    def initialize(receiver=nil, message=nil, test_case=nil, &block)
+      @message = message || "result"
+      @value_proc = block || lambda {
+        receiver.__send__(message)
+      }
+      @test_case = test_case
+    end
+
+    def matches?(event_proc)
+      raise_block_syntax_error if block_given?
+      
+      @before = evaluate_value_proc
+      event_proc.call
+      @after = evaluate_value_proc
+      
+      return false if @from unless @from == @before
+      return false if @to unless @to == @after
+      return (@before + @amount == @after) if @amount
+      return ((@after - @before) >= @minimum) if @minimum
+      return ((@after - @before) <= @maximum) if @maximum        
+      return @before != @after
+    end
+
+    def raise_block_syntax_error
+      raise ArgumentError, "block passed to should or should_not change must use {} instead of do/end"
+    end
+
+    def evaluate_value_proc
+      @value_proc.call
+    end
+
+    def failure_message
+      if @to
+        "#{@message} should have been changed to #{@to.inspect}, but is now #{@after.inspect}"
+      elsif @from
+        "#{@message} should have initially been #{@from.inspect}, but was #{@before.inspect}"
+      elsif @amount
+        "#{@message} should have been changed by #{@amount.inspect}, but was changed by #{actual_delta.inspect}"
+      elsif @minimum
+        "#{@message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+      elsif @maximum
+        "#{@message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
+      else
+        "#{@message} should have changed, but is still #{@before.inspect}"
+      end
+    end
+
+    def actual_delta
+      @after - @before
+    end
+
+    def negative_failure_message
+      "#{@message} should not have changed, but did change from #{@before.inspect} to #{@after.inspect}"
+    end
+
+    def by(amount)
+      @amount = amount
+      self
+    end
+
+    def by_at_least(minimum)
+      @minimum = minimum
+      self
+    end
+
+    def by_at_most(maximum)
+      @maximum = maximum
+      self
+    end      
+
+    def to(to)
+      @to = to
+      self
+    end
+
+    def from (from)
+      @from = from
+      self
+    end
+  end
+
+
+  module TestCaseExtensions
+    def change(receiver=nil, message=nil, &block)
+      Matchy::Expectations::ChangeExpectation.new(receiver, message, self, &block)
+    end
+  end
+end

data/test/helpers/expectations/have.rb

@@ -0,0 +1,105 @@
+module Matchy::Expectations
+  class HaveExpectation < Base
+    def initialize(expected, relativity=:exactly, test_case = nil)
+      @expected = (expected == :no ? 0 : expected)
+      @relativity = relativity
+      @test_case = test_case
+    end
+
+    def relativities
+      @relativities ||= {
+        :exactly => "",
+        :at_least => "at least ",
+        :at_most => "at most "
+      }
+    end
+
+    def matches?(collection_owner)
+      if collection_owner.respond_to?(@collection_name)
+        collection = collection_owner.__send__(@collection_name, *@args, &@block)
+      elsif (@plural_collection_name && collection_owner.respond_to?(@plural_collection_name))
+        collection = collection_owner.__send__(@plural_collection_name, *@args, &@block)
+      elsif (collection_owner.respond_to?(:length) || collection_owner.respond_to?(:size))
+        collection = collection_owner
+      else
+        collection_owner.__send__(@collection_name, *@args, &@block)
+      end
+      @given = collection.size if collection.respond_to?(:size)
+      @given = collection.length if collection.respond_to?(:length)
+      raise not_a_collection if @given.nil?
+      return @given >= @expected if @relativity == :at_least
+      return @given <= @expected if @relativity == :at_most
+      return @given == @expected
+    end
+
+    def not_a_collection
+      "expected #{@collection_name} to be a collection but it does not respond to #length or #size"
+    end
+
+    def failure_message
+      "expected #{relative_expectation} #{@collection_name}, got #{@given}"
+    end
+
+    def negative_failure_message
+      if @relativity == :exactly
+        return "expected target not to have #{@expected} #{@collection_name}, got #{@given}"
+      elsif @relativity == :at_most
+        return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+should_not have_at_most(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+should have_at_least(#{@expected + 1}).#{@collection_name}
+EOF
+      elsif @relativity == :at_least
+        return <<-EOF
+Isn't life confusing enough?
+Instead of having to figure out the meaning of this:
+should_not have_at_least(#{@expected}).#{@collection_name}
+We recommend that you use this instead:
+should have_at_most(#{@expected - 1}).#{@collection_name}
+EOF
+      end
+    end
+
+    def description
+      "have #{relative_expectation} #{@collection_name}"
+    end
+
+    def respond_to?(sym)
+      @expected.respond_to?(sym) || super
+    end
+
+    private
+
+    def method_missing(sym, *args, &block)
+      @collection_name = sym
+      if inflector = (defined?(ActiveSupport::Inflector) ? ActiveSupport::Inflector : (defined?(Inflector) ? Inflector : nil))
+        @plural_collection_name = inflector.pluralize(sym.to_s)
+      end
+      @args = args
+      @block = block
+      self
+    end
+
+    def relative_expectation
+      "#{relativities[@relativity]}#{@expected}"
+    end
+  end
+
+  
+  module TestCaseExtensions
+    def have(n)
+      HaveExpectation.new(n, :exactly, self)
+    end
+    alias :have_exactly :have
+    
+    def have_at_least(n)
+      HaveExpectation.new(n, :at_least, self)
+    end
+    
+    def have_at_most(n)
+      HaveExpectation.new(n, :at_most, self)
+    end
+  end
+end

data/test/helpers/expectations/have_tag.rb

@@ -0,0 +1,128 @@
+require 'hpricot'
+
+# evil hack to duck-type CgiResponse so that nested shoulds can use 
+# +rspec_on_rails+ matchers without remembering to call to_s on it
+#
+# e.g.
+#
+# response.should have_tag("li") do |ul|
+#   ul.should have_text("List Item")      # with hack
+#   ul.to_s.should have_text("List Item") # without hack
+# end
+class Hpricot::Elem
+  alias body to_s
+end
+
+module Matchy::Expectations
+  class HaveTag < Base
+    def initialize(test_case, selector, inner_text_or_options, options, &block)
+        #@expected = expected
+        @test_case = test_case
+      @selector = selector
+
+      if Hash === inner_text_or_options
+        @inner_text = nil
+        @options    = inner_text_or_options
+      else
+        @inner_text = inner_text_or_options
+        @options    = options
+      end
+    end
+
+    def matches?(actual, &block)
+      @actual = actual
+      @doc = hpricot_document(@actual)
+
+      matched_elements = @doc.search(@selector)
+
+      return @options[:count] == 0 if matched_elements.empty?
+
+      matched_elements = filter_on_inner_text(matched_elements) if @inner_text
+      matched_elements = filter_on_nested_expectations(matched_elements, block) if block
+
+      @actual_count = matched_elements.length
+
+      return false unless acceptable_count?(@actual_count)
+
+      !matched_elements.empty?
+    end
+
+    def failure_message
+      explanation = @actual_count ? "but found #{@actual_count}" : "but did not"
+      "expected\n#{@doc.to_s}\nto have #{failure_count_phrase} #{failure_selector_phrase}, #{explanation}"
+    end
+
+    def negative_failure_message
+      explanation = @actual_count ? "but found #{@actual_count}" : "but did"
+      "expected\n#{@doc.to_s}\nnot to have #{failure_count_phrase} #{failure_selector_phrase}, #{explanation}"
+    end
+
+    private
+      def hpricot_document(input)
+        if Hpricot === input
+          input
+        elsif input.respond_to?(:body)
+          Hpricot(input.body)
+        else
+          Hpricot(input.to_s)
+        end
+      end
+
+      def filter_on_inner_text(elements)
+        elements.select do |element|
+          next(element.inner_text =~ @inner_text) if @inner_text.is_a?(Regexp)
+          element.inner_text == @inner_text
+        end
+      end
+
+      def filter_on_nested_expectations(elements, block)
+        elements.select do |el|
+          begin
+            block.call(el)
+          rescue NoMethodError
+            false
+          else
+            true
+          end
+        end
+      end
+
+      def acceptable_count?(actual_count)
+        if @options[:count]
+          return false unless @options[:count] === actual_count
+        end
+        if @options[:minimum]
+          return false unless actual_count >= @options[:minimum]
+        end
+        if @options[:maximum]
+          return false unless actual_count <= @options[:maximum]
+        end
+
+        true
+      end
+
+      def failure_count_phrase
+        if @options[:count]
+          "#{@options[:count]} elements matching"
+        elsif @options[:minimum] || @options[:maximum]
+          count_explanations = []
+          count_explanations << "at least #{@options[:minimum]}" if @options[:minimum]
+          count_explanations << "at most #{@options[:maximum]}"  if @options[:maximum]
+          "#{count_explanations.join(' and ')} elements matching"
+        else
+          "an element matching"
+        end
+      end
+
+      def failure_selector_phrase
+        phrase = @selector.inspect
+        phrase << (@inner_text ? " with inner text #{@inner_text.inspect}" : "")
+      end
+  end
+
+  module TestCaseExtensions
+    def have_tag(selector, inner_text_or_options = nil, options = {}, &block)
+      Matchy::Expectations::HaveTag.new(self, selector, inner_text_or_options, options, &block)
+    end
+  end
+end