integrity-integrity 0.1.9.3

data/test/helpers/acceptance/email_notifier.rb

@@ -0,0 +1,52 @@
+module Integrity
+  class Notifier
+    class Email < Notifier::Base
+      attr_reader :to, :from
+
+      def self.to_haml
+        <<-EOF
+%p.normal
+  %label{ :for => "email_notifier_to" } Send to
+  %input.text#email_notifier_to{ :name => "notifiers[Email][to]", :type => "text", :value => config["to"] }
+
+%p.normal
+  %label{ :for => "email_notifier_from" } Send from
+  %input.text#email_notifier_from{ :name => "notifiers[Email][from]", :type => "text", :value => config["from"] }
+
+%h3 SMTP Server Configuration
+
+%p.normal
+  %label{ :for => "email_notifier_host" } Host : Port
+  = succeed " : " do
+    %input.text#email_notifier_host{ :name => "notifiers[Email][host]", :value => config["host"], :style => "width: 24.5em;", :type => "text" }
+  %input.text#email_notifier_port{ :name => "notifiers[Email][port]", :value => config["port"], :style => "width: 3.5em;", :type => "text" }
+
+%p.normal
+  %label{ :for => "email_notifier_user" } User
+  %input.text#email_notifier_user{ :name => "notifiers[Email][user]", :value => config["user"], :type => "text" }
+
+%p.normal
+  %label{ :for => "email_notifier_pass" } Password
+  %input.text#email_notifier_pass{ :name => "notifiers[Email][pass]", :value => config["pass"], :type => "text" }
+
+%p.normal
+  %label{ :for => "email_notifier_auth" } Auth type
+  %input.text#email_notifier_auth{ :name => "notifiers[Email][auth]", :value => (config["auth"] || "plain"), :type => "text" }
+
+%p.normal
+  %label{ :for => "email_notifier_domain" } Domain
+  %input.text#email_notifier_domain{ :name => "notifiers[Email][domain]", :value => config["domain"], :type => "text" }
+EOF
+      end
+
+      def initialize(build, config={})
+        @to     = config.delete("to")
+        @from   = config.delete("from")
+        super
+      end
+
+      def deliver!
+      end
+    end
+  end
+end

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: %H%n:author: %n :name: %an%n :email: %ae%n)
+          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/notifier_helper.rb

@@ -0,0 +1,47 @@
+module NotifierHelper
+  def fill_in_email_notifier
+    fill_in "notifiers[Email][to]",     :with => "quentin@example.com"
+    fill_in "notifiers[Email][from]",   :with => "ci@example.com"
+    fill_in "notifiers[Email][user]",   :with => "inspector"
+    fill_in "notifiers[Email][pass]",   :with => "gadget"
+    fill_in "notifiers[Email][auth]",   :with => "simple"
+    fill_in "notifiers[Email][domain]", :with => "example.com"
+  end
+
+  def fill_in_project_info(name, repo)
+    fill_in "Name",            :with => name
+    fill_in "Git repository",  :with => repo
+    fill_in "Branch to track", :with => "master"
+    fill_in "Build script",    :with => "rake"
+    check   "Public project"
+
+    fill_in_email_notifier
+  end
+
+  def assert_have_email_notifier
+    assert_have_tag "input#email_notifier_to[@value='quentin@example.com']"
+    assert_have_tag "input#email_notifier_from[@value='ci@example.com']"
+    assert_have_tag "input#email_notifier_user[@value='inspector']"
+    assert_have_tag "input#email_notifier_pass[@value='gadget']"
+    assert_have_tag "input#email_notifier_auth[@value='simple']"
+    assert_have_tag "input#email_notifier_domain[@value='example.com']"
+  end
+
+  def add_project(name, repo)
+    visit "/new"
+    fill_in_project_info(name, repo)
+    click_button "Create Project"
+
+    assert_have_tag("h1", :content => name)
+    click_link 'Edit Project'
+    assert_have_email_notifier
+  end
+
+  def edit_project(name)
+    visit "/#{name}"
+    click_link "Edit Project"
+    assert_have_email_notifier
+    fill_in :branch, :with => "testing"
+    click_button "Update Project"
+  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,4 @@
+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"

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