sr-integrity 0.1.8.1

data/test/helpers/acceptance.rb

@@ -0,0 +1,80 @@
+require "webrat/sinatra"
+require "helpers/acceptance/git_helper"
+
+module AcceptanceHelper
+  include FileUtils
+
+  def export_directory
+    File.dirname(__FILE__) + "/../../exports"
+  end
+
+  def enable_auth!
+    Integrity.config[:use_basic_auth]      = true
+    Integrity.config[:admin_username]      = "admin"
+    Integrity.config[:admin_password]      = "test"
+    Integrity.config[:hash_admin_password] = false
+  end
+
+  def login_as(user, password)
+    def AcceptanceHelper.logged_in; true; end
+    basic_auth user, password
+    visit "/login"
+    Integrity::App.before { login_required if AcceptanceHelper.logged_in }
+  end
+
+  def log_out
+    def AcceptanceHelper.logged_in; false; end
+    @_webrat_session = Webrat::SinatraSession.new(self)
+  end
+
+  def disable_auth!
+    Integrity.config[:use_basic_auth] = false
+  end
+
+  def set_and_create_export_directory!
+    FileUtils.rm_r(export_directory) if File.directory?(export_directory)
+    FileUtils.mkdir(export_directory)
+    Integrity.config[:export_directory] = export_directory
+  end
+
+  def setup_log!
+    log_file = Pathname(File.dirname(__FILE__) + "/../../integrity.log")
+    log_file.delete if log_file.exist?
+    Integrity.config[:log] = log_file
+  end
+end
+
+class Test::Unit::AcceptanceTestCase < Test::Unit::TestCase
+  include AcceptanceHelper
+  include Test::Storyteller
+  include GitHelper
+  include Webrat::Methods
+
+  # TODO: does this belongs in Webrat::SinatraSession?
+  Webrat::Methods.delegate_to_session :response_code
+
+  def app
+    Integrity::App.tap { |app|
+      app.set     :environment, :test
+      app.disable :raise_errors, :run, :reload
+    }
+  end
+
+  before(:all) do
+    Integrity.config[:base_uri] = "http://www.example.com"
+  end
+
+  before(:each) do
+    # ensure each scenario is run in a clean sandbox
+    enable_auth!
+    setup_log!
+    set_and_create_export_directory!
+    log_out
+  end
+
+  after(:each) do
+    destroy_all_git_repos
+    rm_r export_directory if File.directory?(export_directory)
+  end
+
+end

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/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/fixtures.rb

@@ -0,0 +1,107 @@
+include DataMapper::Sweatshop::Unique
+
+class Array
+  def pick
+    self[rand(self.length)]
+  end
+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        => File.dirname(__FILE__) + "/../../",
+    :branch     => "master",
+    :command    => "./test",
+    :public     => true,
+    :building   => false }
+end
+
+Integrity::Commit.fixture do
+  project = Integrity::Project.first || Integrity::Project.gen
+
+  { :identifier =>   Digest::SHA1.hexdigest(/[:paragraph:]/.gen),
+    :message =>      /[:sentence:]/.gen,
+    :author =>       /\w+ \w+ <\w+@example.org>/.gen,
+    :committed_at => unique {|i| Time.mktime(2008, 12, 15, 18, (59 - i) % 60) },
+    :project_id =>   project.id }
+end
+
+Integrity::Commit.fixture(:successful) do
+  Integrity::Commit.generate_attributes.update(:build => Integrity::Build.gen(:successful))
+end
+
+Integrity::Commit.fixture(:failed) do
+  Integrity::Commit.generate_attributes.update(:build => Integrity::Build.gen(:failed))
+end
+
+Integrity::Commit.fixture(:pending) do
+  Integrity::Commit.generate_attributes.update(:build => Integrity::Build.gen(:pending))
+end
+
+Integrity::Build.fixture do
+  commit = Integrity::Commit.first || Integrity::Commit.gen
+
+  { :output       => /[:paragraph:]/.gen,
+    :successful   => true,
+    :started_at   => unique {|i| Time.mktime(2008, 12, 15, 18, i % 60) },
+    :created_at   => unique {|i| Time.mktime(2008, 12, 15, 18, i % 60) },
+    :completed_at => unique {|i| Time.mktime(2008, 12, 15, 18, i % 60) },
+    :commit_id    => commit.id }
+end
+
+Integrity::Build.fixture(:successful) do
+  Integrity::Build.generate_attributes.update(:successful => true)
+end
+
+Integrity::Build.fixture(:failed) do
+  Integrity::Build.generate_attributes.update(:successful => false)
+end
+
+Integrity::Build.fixture(:pending) do
+  Integrity::Build.generate_attributes.update(:successful => nil, :started_at => nil, :completed_at => nil)
+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

data/test/helpers/initial_migration_fixture.sql

@@ -0,0 +1,44 @@
+CREATE TABLE "integrity_builds" ("id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "output" TEXT NOT NULL DEFAULT '', "successful" BOOLEAN NOT NULL DEFAULT 'f', "commit_identifier" VARCHAR(50) NOT NULL, "commit_metadata" TEXT NOT NULL, "created_at" DATETIME, "updated_at" DATETIME, "project_id" INTEGER);
+INSERT INTO "integrity_builds" VALUES(1,'rake aborted!
+Don''t know how to build task ''default''
+/home/simon/.gems/gems/rake-0.8.3/lib/rake.rb:1706:in `[]''
+(See full trace by running task with --trace)
+(in /home/simon/bar/builds/sr-shout-bot-master)
+','f','348e9e27fa72645518fc539b77f1c37fcc20ab11','---
+:message: had to allow for registration time
+:date: 2009-01-04 06:19:30 +0800
+:author: syd <syd@teh.magicha.us>
+','2009-02-17T19:48:31+01:00','2009-02-17T19:48:31+01:00',1);
+INSERT INTO "integrity_builds" VALUES(2,'....*...........
+
+Pending:
+ShoutBot When using Shouter.shout passes given block to join (TODO)
+  Called from shout-bot.rb:113
+
+Finished in 10.222458 seconds
+
+16 examples, 0 failures, 1 pending
+','t','348e9e27fa72645518fc539b77f1c37fcc20ab11','---
+:message: had to allow for registration time
+:date: 2009-01-04 06:19:30 +0800
+:author: syd <syd@teh.magicha.us>
+','2009-02-17T19:49:05+01:00','2009-02-17T19:49:05+01:00',1);
+INSERT INTO "integrity_builds" VALUES(3,'(in /home/simon/bar/builds/sinatra-sinatra-master)
+Loaded suite /home/simon/.gems/gems/rake-0.8.3/lib/rake/rake_test_loader
+Started
+.......................................................................................................................................................................................................................................
+Finished in 1.097704 seconds.
+
+231 tests, 437 assertions, 0 failures, 0 errors
+','t','a2f5803ec642c43ece86ad96676c45f44fe3746e','---
+:message: Allow dot in named param capture [#153]
+:date: 2009-02-17 09:32:58 -0800
+:author: Ryan Tomayko <rtomayko@gmail.com>
+','2009-02-17T19:50:11+01:00','2009-02-17T19:50:11+01:00',2);
+DELETE FROM sqlite_sequence;
+INSERT INTO "sqlite_sequence" VALUES('integrity_projects',2);
+INSERT INTO "sqlite_sequence" VALUES('integrity_builds',3);
+CREATE TABLE "integrity_notifiers" ("id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "name" VARCHAR(50) NOT NULL, "config" TEXT NOT NULL, "project_id" INTEGER);
+CREATE TABLE "integrity_projects" ("id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, "name" VARCHAR(50) NOT NULL, "permalink" VARCHAR(50), "uri" VARCHAR(255) NOT NULL, "branch" VARCHAR(50) NOT NULL DEFAULT 'master', "command" VARCHAR(255) NOT NULL DEFAULT 'rake', "public" BOOLEAN DEFAULT 't', "building" BOOLEAN DEFAULT 'f', "created_at" DATETIME, "updated_at" DATETIME);
+INSERT INTO "integrity_projects" VALUES(1,'Shout Bot','shout-bot','git://github.com/sr/shout-bot.git','master','ruby shout-bot.rb','t','f','2009-02-17T19:48:23+01:00','2009-02-17T19:49:05+01:00');
+INSERT INTO "integrity_projects" VALUES(2,'Sinatra','sinatra','git://github.com/sinatra/sinatra.git','master','rake compat test','t','f','2009-02-17T19:49:48+01:00','2009-02-17T19:50:22+01:00');

data/test/helpers.rb

@@ -0,0 +1,70 @@
+$:.unshift File.dirname(__FILE__) + "/../lib", File.dirname(__FILE__),
+  File.dirname(__FILE__) + "/../vendor/webrat/lib"
+
+begin
+  require "test/unit"
+  require "redgreen"
+  require "context"
+  require "storyteller"
+  require "pending"
+  require "matchy"
+  require "rr"
+  require "mocha"
+  require "ruby-debug"
+  require "test/zentest_assertions"
+  require "dm-sweatshop"
+rescue LoadError
+  puts "You're missing some gems required to run the tests."
+  puts "Please run `rake test:install_dependencies`"
+  puts "You'll probably need to run that command as root or with sudo."
+  puts
+  puts "Thanks :)"
+  puts
+
+  exit 1
+end
+
+require "integrity"
+require "helpers/expectations"
+require "helpers/fixtures"
+
+module TestHelper
+  def ignore_logs!
+    Integrity.config[:log] = "/tmp/integrity.test.log"
+  end
+end
+
+class Test::Unit::TestCase
+  class << self
+    alias_method :specify, :test
+  end
+
+  include RR::Adapters::TestUnit
+  include Integrity
+  include TestHelper
+
+  before(:all) do
+    DataMapper.setup(:default, "sqlite3::memory:")
+  end
+
+  before(:each) do
+    RR.reset
+    DataMapper.auto_migrate!
+    Integrity.instance_variable_set(:@config, nil)
+
+    repository(:default) do
+      transaction = DataMapper::Transaction.new(repository)
+      transaction.begin
+      repository.adapter.push_transaction(transaction)
+    end
+  end
+
+  after(:each) do
+    repository(:default) do
+      while repository.adapter.current_transaction
+        repository.adapter.current_transaction.rollback
+        repository.adapter.pop_transaction
+      end
+    end
+  end
+end