foca-integrity 0.1.4 → 0.1.6

data/lib/integrity/{builder.rb → project_builder.rb}

@@ -1,7 +1,5 @@
-require 'fileutils'
-
 module Integrity
-  class Builder
+  class ProjectBuilder
     attr_reader :build_script
 
     def initialize(project)

data/lib/integrity/scm/git.rb

@@ -44,7 +44,7 @@ module Integrity
     
         def clone
           log "Cloning #{uri} to #{working_directory}"
-          `git clone #{uri} #{working_directory}`
+          `git clone #{uri} #{working_directory} &>/dev/null`
         end
 
         def checkout(treeish=nil)
@@ -55,12 +55,12 @@ module Integrity
           end
 
           log "Checking-out #{strategy}"
-          `cd #{working_directory} && git checkout #{strategy}`
+          `cd #{working_directory} && git checkout #{strategy} &>/dev/null`
         end
 
         def pull
           log "Pull-ing in #{working_directory}"
-          `cd #{working_directory} && git pull`
+          `cd #{working_directory} && git pull &>/dev/null`
         end
 
         def local_branches
@@ -72,7 +72,7 @@ module Integrity
         end
 
         def on_branch?
-          File.basename(`cd #{working_directory} && git symbolic-ref HEAD`).chomp == branch
+          File.basename(`cd #{working_directory} && git symbolic-ref HEAD &>/dev/null`).chomp == branch
         end
 
         def log(message)

data/lib/integrity/scm.rb

@@ -5,18 +5,15 @@ module Integrity
     def self.new(uri, *args)
       scm_class_for(uri).new(uri, *args)
     end
-    
+
     def self.working_tree_path(uri)
       scm_class_for(uri).working_tree_path(uri)
     end
-    
+
     private
-  
-      def self.scm_class_for(string)
-        case string.to_s
-          when /\.git\/?/ then Git
-          else raise SCMUnknownError, "could not find any SCM based on string '#{string}'"
-        end
+      def self.scm_class_for(uri)
+        return Git if uri.scheme == "git" || uri.path =~ /\.git\/?/
+        raise SCMUnknownError, "could not find any SCM based on URI '#{uri.to_s}'"
       end
   end
 end

data/lib/integrity.rb

@@ -1,32 +1,35 @@
 __DIR__ = File.dirname(__FILE__)
 $:.unshift "#{__DIR__}/integrity", *Dir["#{__DIR__}/../vendor/**/lib"].to_a
 
-require 'rubygems'
-require 'json'
-require 'dm-core'
-require 'dm-validations'
-require 'dm-types'
-require 'dm-timestamps'
-require 'dm-aggregates'
+require "rubygems"
+require "json"
+require "dm-core"
+require "dm-validations"
+require "dm-types"
+require "dm-timestamps"
+require "dm-aggregates"
 
-require 'yaml'
-require 'logger'
-require 'digest/sha1'
+require "yaml"
+require "logger"
+require "digest/sha1"
+require "timeout"
+require "ostruct"
+require "fileutils"
 
-require 'core_ext/object'
-require 'core_ext/string'
-require 'core_ext/time'
+require "core_ext/object"
+require "core_ext/string"
 
-require 'project'
-require 'build'
-require 'builder'
-require 'scm'
-require 'scm/git'
-require 'notifier'
+require "project"
+require "build"
+require "project_builder"
+require "scm"
+require "scm/git"
+require "notifier"
 
 module Integrity
   def self.new(config_file = nil)
     self.config = config_file unless config_file.nil?
+    DataMapper.logger = self.logger if config[:log_debug_info]
     DataMapper.setup(:default, config[:database_uri])
   end
 
@@ -35,12 +38,13 @@ module Integrity
   end
 
   def self.default_configuration
-    @defaults ||= { :database_uri      => 'sqlite3::memory:',
-                    :export_directory  => root / 'exports',
+    @defaults ||= { :database_uri      => "sqlite3::memory:",
+                    :export_directory  => root / "exports",
                     :log               => STDOUT,
-                    :base_uri          => 'http://localhost:8910',
+                    :base_uri          => "http://localhost:8910",
                     :use_basic_auth    => false,
-                    :build_all_commits => true}
+                    :build_all_commits => true,
+                    :log_debug_info    => false }
   end
 
   def self.config
@@ -50,7 +54,7 @@ module Integrity
   def self.config=(file)
     @config = default_configuration.merge(YAML.load_file(file))
   end
-  
+
   def self.log(message, &block)
     logger.info(message, &block)
   end
@@ -60,9 +64,16 @@ module Integrity
       logger.formatter = LogFormatter.new
     end
   end
-  
+
+  def self.version
+    @version ||= begin
+      file = YAML.load_file(Integrity.root / "VERSION.yml")
+      "#{file['major']}.#{file['minor']}.#{file['patch']}"
+    end
+  end
+
   private
-  
+
     class LogFormatter < Logger::Formatter
       def call(severity, time, progname, msg)
         time.strftime("[%H:%M:%S] ") + msg2str(msg) + "\n"

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

@@ -0,0 +1,126 @@
+require 'webrat/rack'
+require 'sinatra'
+require 'sinatra/test'
+
+disable :run
+disable :reload
+
+Webrat.configuration.instance_variable_set("@mode", :sinatra)
+
+module Webrat
+  class SinatraSession < Session
+    DEFAULT_DOMAIN = "integrity.example.org"
+
+    def initialize(context = nil)
+      super(context)
+      @sinatra_test = Sinatra::TestHarness.new
+    end
+
+    %w(get head post put delete).each do |verb|
+      class_eval <<-METHOD
+        def #{verb}(path, data, headers = {})
+          params = data.inject({}) do |data, (key,value)|
+            data[key] = Rack::Utils.unescape(value)
+            data
+          end
+          headers['HTTP_HOST'] = DEFAULT_DOMAIN
+          @sinatra_test.#{verb}(path, params, headers)
+        end
+      METHOD
+    end
+
+    def response_body
+      @sinatra_test.body
+    end
+
+    def response_code
+      @sinatra_test.status
+    end
+
+    private
+
+    def response
+      @sinatra_test.response
+    end
+
+    def current_host
+      URI.parse(current_url).host || DEFAULT_DOMAIN
+    end
+
+    def response_location_host
+      URI.parse(response_location).host || DEFAULT_DOMAIN
+    end
+  end
+end
+
+require Integrity.root / "app"
+require File.dirname(__FILE__) / "acceptance/git_helper"
+
+module AcceptanceHelper
+  include FileUtils
+
+  def export_directory
+    Integrity.root / "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"
+    Sinatra::Application.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!
+    pathname = Integrity.root / "integrity.log"
+    FileUtils.rm pathname if File.exists?(pathname)
+    Integrity.config[:log] = pathname
+  end
+end
+
+class Test::Unit::AcceptanceTestCase < Test::Unit::TestCase
+  include AcceptanceHelper
+  include Test::Storyteller
+  include GitHelper
+  include Webrat::Methods
+  Webrat::Methods.delegate_to_session :response_code
+
+  before(:all) do
+    Integrity.config[:base_uri] = "http://#{Webrat::SinatraSession::DEFAULT_DOMAIN}"
+  end
+
+  before(:each) do
+    # ensure each scenario is run in a clean sandbox
+    setup_and_reset_database!
+    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