brycethornton-integrity 0.1.7.1

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

data/test/helpers/expectations/predicates.rb

@@ -0,0 +1,37 @@
+module Matchy::Expectations
+  class PredicateExpectation < Base
+    def initialize(predicate, *arguments)
+      @test_case = arguments.pop
+      @predicate = predicate
+      @arguments = arguments
+    end
+    
+    def matches?(receiver)
+      @receiver = receiver
+      @receiver.send("#{@predicate}?", *@arguments)
+    end
+    
+    def failure_message
+      message = "Expected #{@receiver.inspect} to be #{@predicate}"
+      message << " with #{@arguments.map {|e| e.inspect }.join(", ")}" unless @arguments.empty?
+      message
+    end
+
+    def negative_failure_message
+      message = "Expected #{@receiver.inspect} not to be #{@predicate}"
+      message << " with #{@arguments.map {|e| e.inspect }.join(", ")}" unless @arguments.empty?
+      message
+    end
+  end
+  
+  module TestCaseExtensions
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /^be_(.*)/
+        args << self
+        Matchy::Expectations::PredicateExpectation.new($1, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/test/helpers/fixtures.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'dm-sweatshop'
+
+include DataMapper::Sweatshop::Unique
+
+class Array
+  def pick
+    self[rand(self.length)]
+  end
+end
+
+def commit_metadata
+  meta_data = <<-EOS
+---
+:author: #{/\w+ \w+ <\w+@example.org>/.gen}
+:message: >-
+  #{/\w+/.gen}
+:date: #{unique {|i| Time.mktime(2008, 12, 15, 18, (59 - i) % 60) }}
+EOS
+end
+
+def create_notifier!(name)
+  klass = Class.new(Integrity::Notifier::Base) do
+    def self.to_haml; "";   end
+    def deliver!;     nil;  end
+  end
+
+  unless Integrity::Notifier.const_defined?(name)
+    Integrity::Notifier.const_set(name, klass)
+  end
+end
+
+
+Integrity::Project.fixture do
+  { :name       => (name = unique { /\w+/.gen }),
+    :uri        => "git://github.com/#{/\w+/.gen}/#{name}.git",
+    :branch     => ["master", "test-refactoring", "lh-34"].pick,
+    :command    => ["rake", "make", "ant -buildfile test.xml"].pick,
+    :public     => [true, false].pick,
+    :building   => [true, false].pick }
+end
+
+Integrity::Project.fixture(:integrity) do
+  { :name       => "Integrity",
+    :uri        => "git://github.com/foca/integrity.git",
+    :branch     => "master",
+    :command    => "rake",
+    :public     => true,
+    :building   => false }
+end
+
+Integrity::Project.fixture(:my_test_project) do
+  { :name       => "My Test Project",
+    :uri        => Integrity.root / "my-test-project",
+    :branch     => "master",
+    :command    => "./test",
+    :public     => true,
+    :building   => false }
+end
+
+Integrity::Build.fixture do
+  { :output     => /[:paragraph:]/.gen,
+    :successful => true,
+    :created_at => unique {|i| Time.mktime(2008, 12, 15, 18, (59 - i) % 60) },
+    :commit_identifier => Digest::SHA1.hexdigest(/[:paragraph:]/.gen),
+    :commit_metadata   => commit_metadata }
+end
+
+Integrity::Notifier.fixture(:irc) do
+  create_notifier! "IRC"
+
+  { :project => Integrity::Project.generate,
+    :name => "IRC",
+    :config => { :uri => "irc://irc.freenode.net/integrity" }}
+end
+
+Integrity::Notifier.fixture(:twitter) do
+  create_notifier! "Twitter"
+
+  { :project => Integrity::Project.generate,
+    :name => "Twitter",
+    :config => { :email => "foo@example.org", :pass => "secret" }}
+end