bengler_test_helper 0.0.3

data/.gitignore

@@ -0,0 +1,13 @@
+*~
+.DS_Store
+/.bundle
+/log
+/tmp
+/trash
+.rvmrc
+*.sublime-project
+*.sublime-workspace
+.rspec
+/coverage
+Gemfile.lock
+/pkg

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in bengler_test_helper.gemspec
+gemspec

data/README.md

@@ -0,0 +1,24 @@
+This is common test stuff that can be used by Ruby apps.
+
+Tasks
+-----
+
+To include tasks, add a Rakefile to your project containing the following:
+
+  require 'bengler_test_helper/tasks'
+
+This adds:
+
+* `rake db:structure:load`: Loads test database with schema from `db/development_structure.sql`.
+
+Also, it overrides Rails' default tasks:
+
+* `rake db:migrate`: Automatically saves schema to `db/development_structure.sql`
+  by invoking `db:structure:dump`.
+* `rake db:test:prepare`: Instead of dumping schema from development database,
+  it loads bootstrap data form `db/bootstrap.sql` and uses `db:structure:load`.
+
+For non-Rails projects, the following Rails-compatible tasks are provided:
+
+* `rake db:structure:dump`: Saves schema to `db/development_structure.sql` like
+   you would expect.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bengler_test_helper.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path("../lib", __FILE__)
+require "bengler_test_helper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bengler_test_helper"
+  s.version     = BenglerTestHelper::VERSION
+  s.authors     = ["Alexander Staubo"]
+  s.email       = ["alex@origo.no"]
+  s.homepage    = ""
+  s.summary     = %q{This is common test stuff that can be used by Ruby apps.}
+  s.description = %q{This is common test stuff that can be used by Ruby apps.}
+  s.rubyforge_project = "bengler_test_helper"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+end

data/lib/bengler_test_helper/active_record.rb

@@ -0,0 +1,15 @@
+module BenglerTestHelper
+  module ActiveRecord
+
+    class << self
+      def database_configuration(environment)
+        require 'active_record'
+        ::ActiveRecord::Base.configurations = YAML.load(File.open('config/database.yml'))
+        config = ::ActiveRecord::Base.configurations[environment]
+        raise "No database configuration for environment #{environment.inspect}." unless config
+        config
+      end
+    end
+
+  end
+end

data/lib/bengler_test_helper/tasks.rb

@@ -0,0 +1,32 @@
+raise 'bengler_test_helper should only be loaded in the development or test envs.' unless ['development', 'test'].include?(ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development')
+
+require 'rake' unless defined?(Rake)
+
+Rake::TaskManager.class_eval do
+  unless method_defined?(:remove_task)
+    def remove_task(task_name)
+      @tasks.delete(task_name.to_s)
+    end
+  end
+end
+
+begin
+  # If there's no active record, we don't care.
+  require 'active_record'
+
+  Rake.application.remove_task :"db:test:prepare"
+  Rake.application.remove_task :"db:structure:dump"
+
+  require 'bengler_test_helper/active_record'
+  require 'bengler_test_helper/tasks/db_migrate'
+  require 'bengler_test_helper/tasks/db_structure_dump'
+  require 'bengler_test_helper/tasks/db_structure_load'
+  require 'bengler_test_helper/tasks/db_test_config'
+  require 'bengler_test_helper/tasks/db_test_create'
+  require 'bengler_test_helper/tasks/db_test_prepare'
+
+rescue LoadError => e
+  puts "We can't load ActiveRecord. That might be fine. #{e.message}"
+rescue Exception => e
+  puts "Bengel Tools Fail. #{e.message}."
+end

data/lib/bengler_test_helper/tasks/db_migrate.rb

@@ -0,0 +1,5 @@
+namespace :db do
+  Rake::Task['migrate'].enhance do
+    Rake::Task['db:structure:dump'].invoke unless ENV['RACK_ENV'] == 'development'
+  end
+end

data/lib/bengler_test_helper/tasks/db_structure_dump.rb

@@ -0,0 +1,28 @@
+require 'tempfile'
+
+namespace :db do
+  namespace :structure do
+    desc 'Dump database schema to development_structure.sql'
+    task :dump do
+      config = BenglerTestHelper::ActiveRecord.database_configuration(ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development')
+      abort "Database configuration must use localhost." unless %w(localhost 127.0.0.1).include?(config['host'])
+
+      schema_file_name = 'db/development_structure.sql'
+      Tempfile.open('schema') do |tempfile|
+        tempfile.close
+        unless system("pg_dump --format=p --schema-only --no-owner --no-privileges " \
+          "-U '#{config['username']}' -f '#{tempfile.path}' '#{config['database']}'")
+          abort "Failed to dump SQL."
+        end
+        old_data = File.read(schema_file_name) rescue nil
+        new_data = File.read(tempfile.path)
+        if old_data != new_data
+          $stderr.puts "Dumping new schema to #{schema_file_name}."
+          File.open(schema_file_name, 'w') { |file| file << new_data }
+        else
+          $stderr.puts "Scheme has not changed, not updating #{schema_file_name}."
+        end
+      end
+    end
+  end
+end

data/lib/bengler_test_helper/tasks/db_structure_load.rb

@@ -0,0 +1,16 @@
+namespace :db do
+  namespace :structure do
+    desc 'Recreate test database from development_structure.sql'
+    task :load do
+      config = BenglerTestHelper::ActiveRecord.database_configuration('test')
+      abort 'Database configuration must use localhost.' unless %w(localhost 127.0.0.1).include?(config['host'])
+
+      schema_file_name = 'db/development_structure.sql'
+      unless system("psql -1 -q -o /dev/null --no-psqlrc -d '#{config['database']}' -f '#{schema_file_name}'")
+        abort "Failed to load SQL from #{schema_file_name}. Ensure that your own Postgres user is a superuser."
+      end
+
+      $stderr.puts "Database #{config['database']} loaded from #{schema_file_name}."
+    end
+  end
+end

data/lib/bengler_test_helper/tasks/db_test_config.rb

@@ -0,0 +1,21 @@
+namespace :db do
+  namespace :test do
+    desc 'Sets up a database config file.'
+    task :config do
+      require 'bundler'
+      b = Bundler.setup
+      name = File.basename(`git config --get remote.origin.url`.strip, '.git')
+      File.open('config/database.yml', 'w') do |f|
+        f.write <<-end
+test:
+  adapter: #{b.gems['activerecord-postgis-adapter'].empty? ? 'postgresql' : 'postgis'}
+  host: localhost
+  database: #{name}_test
+  username: #{name}
+  password: #{(0...8).map{(97+rand(26)).chr}.join}
+  encoding: unicode
+end
+      end
+    end
+  end
+end

data/lib/bengler_test_helper/tasks/db_test_create.rb

@@ -0,0 +1,25 @@
+namespace :db do
+  namespace :test do
+    desc 'Creates a test database.'
+    task :create do
+      config = BenglerTestHelper::ActiveRecord.database_configuration('test')
+      abort 'Database configuration must use localhost.' unless %w(localhost 127.0.0.1).include?(config['host'])
+
+      unless system("psql -tA postgres -c '\\du' | grep -E '^#{config['username']}\\|' >/dev/null")
+        unless system("psql postgres -q -c \"CREATE ROLE #{config['username']} SUPERUSER LOGIN PASSWORD '#{config['password']}'\"")
+          abort "Could not create database user '#{config['username']}'"
+        end
+      end
+
+      if system("psql -ltA | grep -E '^#{config['database']}\\|' >/dev/null")
+        unless system("dropdb '#{config['database']}'")
+          abort "Could not drop database '#{config['database']}'"
+        end
+      end
+
+      unless system("createdb -O '#{config['username']}' '#{config['database']}'")
+        abort "Could not create database '#{config['database']}'"
+      end
+    end
+  end
+end

data/lib/bengler_test_helper/tasks/db_test_prepare.rb

@@ -0,0 +1,19 @@
+namespace :db do
+  namespace :test do
+    desc 'Prepare database for running tests.'
+    task :prepare do
+      Rake::Task['db:test:config'].invoke if ENV['SEMAPHORE'] or not File.exists?'config/database.yml'
+      Rake::Task['db:test:create'].invoke
+      Rake::Task['db:structure:load'].invoke
+
+      bootstrap_file_name = File.expand_path('db/bootstrap.sql', '.')
+      if File.exist?(bootstrap_file_name)
+        config = BenglerTestHelper::ActiveRecord.database_configuration('test')
+        unless system("psql -q -o /dev/null --no-psqlrc -d '#{config['database']}' -f '#{bootstrap_file_name}'")
+          abort "Failed to load SQL from #{bootstrap_file_name}."
+        end
+        $stderr.puts "Loaded bootstrap data from #{bootstrap_file_name}."
+      end
+    end
+  end
+end

data/lib/bengler_test_helper/version.rb

@@ -0,0 +1,3 @@
+module BenglerTestHelper
+  VERSION = '0.0.3'
+end

data/lib/rspec/core/formatters/junit_formatter.rb

@@ -0,0 +1,71 @@
+require "time"
+require "rspec/core/formatters/base_formatter"
+
+class JUnitFormatter < RSpec::Core::Formatters::BaseFormatter
+
+  attr_reader :test_results
+
+  def initialize(output)
+    super(output)
+    @test_results = { :failures => [], :successes => [] }
+  end
+
+  def example_passed(example)
+    super(example)
+    @test_results[:successes].push(example)
+  end
+
+  def example_pending(example)
+    super(example)
+    # let jenkins ignore this
+  end
+
+  def example_failed(example)
+    super(example)
+    @test_results[:failures].push(example)
+  end
+
+  def extract_errors(example)
+    exception = example.metadata[:execution_result][:exception_encountered] || example.metadata[:execution_result][:exception]
+    message = ""
+    unless exception.nil?
+      message  = exception.message
+      message += "\n"
+      message += format_backtrace(exception.backtrace, example).join("\n")
+    end
+    return message
+  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    super(duration, example_count, failure_count, pending_count)
+    output.puts("<?xml version=\"1.0\" encoding=\"utf-8\" ?>")
+    output.puts("<testsuite errors=\"0\" failures=\"#{failure_count+pending_count}\" tests=\"#{example_count}\" time=\"#{duration}\" timestamp=\"#{Time.now.iso8601}\">")
+    output.puts("  <properties />")
+    @test_results[:successes].each do |t|
+      md          = t.metadata
+      runtime     = md[:execution_result][:run_time]
+      description = _xml_escape(md[:full_description])
+      file_path   = _xml_escape(md[:file_path])
+      output.puts("  <testcase classname=\"#{file_path}\" name=\"#{description}\" time=\"#{runtime}\" />")
+    end
+    @test_results[:failures].each do |t|
+      md          = t.metadata
+      description = _xml_escape(md[:full_description])
+      file_path   = _xml_escape(md[:file_path])
+      runtime     = md[:execution_result][:run_time]
+      output.puts("  <testcase classname=\"#{file_path}\" name=\"#{description}\" time=\"#{runtime}\">")
+      output.puts("    <failure message=\"failure\" type=\"failure\">")
+      output.puts("<![CDATA[ #{extract_errors(t)} ]]>")
+      output.puts("    </failure>")
+      output.puts("  </testcase>")
+    end
+    output.puts("</testsuite>")
+  end
+
+  def _xml_escape(x)
+    x.gsub("&", "&amp;").
+      gsub("\"", "&quot;").
+      gsub(">", "&gt;").
+      gsub("<", "&lt;")
+  end
+end

data/spec/junit_formatter_spec.rb

@@ -0,0 +1,125 @@
+require 'rspec/core/formatters/junit_formatter'
+
+describe JUnitFormatter do
+  let(:now) { Time.now.utc }
+  let(:output) { StringIO.new }
+  let(:formatter) { JUnitFormatter.new output }
+
+  before(:each) { Time.stub(:now => now) }
+
+  it "starts with no failures and no successes" do
+    JUnitFormatter.new(StringIO.new).test_results.should eq({:failures=>[], :successes=>[]})
+  end
+
+  it "adds passing spec to the success list" do
+    formatter.example_passed "passing spec"
+    formatter.test_results[:successes].should eq ["passing spec"]
+  end
+
+  it "adds failing spec to failure list" do
+    formatter.example_failed "failing spec"
+    formatter.test_results[:failures].should eq ["failing spec"]
+  end
+
+  it "ignores pending specs" do
+    formatter.example_pending "pending spec"
+    formatter.test_results.should eq({:failures=>[], :successes=>[]})
+  end
+
+  describe "#extract_errors" do
+    let(:example) { stub(:example) }
+
+    it "is empty when there are no failures" do
+      metadata = {:execution_result => { :exception_encountered => nil, :exception => nil }}
+      example.stub(:metadata => metadata)
+
+      formatter.extract_errors(example).should eq("")
+    end
+
+    context "with a stacktrace" do
+      let(:stacktrace) { stub(:stacktrace, :message => "foobar", :backtrace => ["foo", "bar"]) }
+
+      it "extracts errors from :exception field" do
+        metadata = {:execution_result => {:exception_encountered => nil, :exception => stacktrace }}
+        example.stub(:metadata => metadata)
+
+        formatter.extract_errors(example).should eq("foobar\nfoo\nbar")
+      end
+
+      it "extracts errors from :exception_encountered field" do
+        metadata = {:execution_result => {:exception_encountered => stacktrace}}
+        example.stub(:metadata => metadata)
+        formatter.extract_errors(example).should eq("foobar\nfoo\nbar")
+      end
+    end
+  end
+
+  describe "junit xml" do
+    let(:passing_metadata) do
+      {
+        :full_description => "a passing spec",
+        :file_path => "/path/to/passing_spec.rb",
+        :execution_result => { :run_time => 0.1 }
+      }
+    end
+
+    let(:failing_metadata) do
+      {
+        :full_description => "a failing spec",
+        :file_path => "/path/to/failing_spec.rb",
+        :execution_result => { :exception_encountered => stacktrace, :run_time => 0.1 }
+      }
+    end
+
+    let(:metadata_with_funky_characters) do
+      {
+        :full_description => "a passing spec >>> &\"& <<<",
+        :file_path => "/path/to/passing_spec.rb",
+        :execution_result => { :run_time => 0.1 }
+      }
+    end
+
+    let(:stacktrace) { stub(:stacktrace, :message => "foobar", :backtrace => ["foo", "bar"]) }
+    let(:passing_spec) { stub(:passing_spec) }
+    let(:failing_spec) { stub(:failing_spec, :metadata => failing_metadata) }
+
+    it "outputs the junit xml" do
+      passing_spec.stub(:metadata => passing_metadata)
+
+      formatter.example_passed passing_spec
+      formatter.example_failed failing_spec
+
+      formatter.dump_summary("0.1", 2, 1, 0)
+
+      expected = <<-REPORT
+<?xml version="1.0" encoding="utf-8" ?>
+<testsuite errors="0" failures="1" tests="2" time="0.1" timestamp="#{now.iso8601}">
+  <properties />
+  <testcase classname="/path/to/passing_spec.rb" name="a passing spec" time="0.1" />
+  <testcase classname="/path/to/failing_spec.rb" name="a failing spec" time="0.1">
+    <failure message="failure" type="failure">
+<![CDATA[ foobar\nfoo\nbar ]]>
+    </failure>
+  </testcase>
+</testsuite>
+      REPORT
+      output.string.should eq expected
+    end
+
+    it "escapes funky characters" do
+      passing_spec.stub(:metadata => metadata_with_funky_characters)
+
+      formatter.example_passed passing_spec
+      formatter.dump_summary("0.1", 2, 1, 0)
+
+      expected = <<-REPORT
+<?xml version="1.0" encoding="utf-8" ?>
+<testsuite errors="0" failures="1" tests="2" time="0.1" timestamp="#{now.iso8601}">
+  <properties />
+  <testcase classname="/path/to/passing_spec.rb" name="a passing spec &gt;&gt;&gt; &amp;&quot;&amp; &lt;&lt;&lt;" time="0.1" />
+</testsuite>
+      REPORT
+      output.string.should eq expected
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: bengler_test_helper
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Alexander Staubo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This is common test stuff that can be used by Ruby apps.
+email:
+- alex@origo.no
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bengler_test_helper.gemspec
+- lib/bengler_test_helper.rb
+- lib/bengler_test_helper/active_record.rb
+- lib/bengler_test_helper/tasks.rb
+- lib/bengler_test_helper/tasks/db_migrate.rb
+- lib/bengler_test_helper/tasks/db_structure_dump.rb
+- lib/bengler_test_helper/tasks/db_structure_load.rb
+- lib/bengler_test_helper/tasks/db_test_config.rb
+- lib/bengler_test_helper/tasks/db_test_create.rb
+- lib/bengler_test_helper/tasks/db_test_prepare.rb
+- lib/bengler_test_helper/version.rb
+- lib/rspec/core/formatters/junit_formatter.rb
+- spec/junit_formatter_spec.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4559941765150812453
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4559941765150812453
+requirements: []
+rubyforge_project: bengler_test_helper
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: This is common test stuff that can be used by Ruby apps.
+test_files:
+- spec/junit_formatter_spec.rb