sqltestrunner 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+cbs

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p327

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,12 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rob Westgeest
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Sqltestrunner
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sqltestrunner'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sqltestrunner
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

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

data/bin/sqltestrunner

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('../lib', File.dirname(__FILE__))
+require 'optparse'
+require 'ostruct'
+require 'sql_test_runner'
+require 'sqlite_connection'
+
+PARSE_ERROR  = 255
+RUNNER_ERROR = 254
+CONNECTION_ERROR = 253
+
+module SqlTestRunner
+  database_options = OpenStruct.new(:database => 'sqlite', :connection => ':memory:')
+
+  option_parser = OptionParser.new do |opts|
+    opts.banner = "Usage #{__FILE__} [options] scriptfile"
+
+    opts.on("-d", "--database [databasetype]", "use database type (default sqlite)") do |database|
+      database_options.database = database
+    end
+    opts.on("-c", "--connection [connection]", "use database connection (default :memory:)") do |connection|
+      database_options.connection = connection
+    end
+
+    opts.on_tail("-h", "--help", "Show this message") do
+      puts opts
+      exit(PARSE_ERROR)
+    end
+  end
+  option_parser.parse!
+
+  file = ARGV.first
+
+  if file.nil? 
+    puts option_parser 
+    exit(PARSE_ERROR) 
+  end
+
+  begin
+    runner = Runner.new(SqliteConnection.new(database_options.connection), TestResult.new(ReportingStepLogger.new))
+    runner.run_file(file)
+  rescue ConnectionError => e
+    puts e.message
+    exit(CONNECTION_ERROR)
+  rescue Exception => e
+    puts e.message
+    exit(RUNNER_ERROR)
+  end
+end

data/examples/creating_a_person_test.sql

@@ -0,0 +1,33 @@
+before "creating the person table" do
+  execute """
+    CREATE TABLE IF NOT EXISTS Person(
+      Id INTEGER PRIMARY KEY,
+      Name VARCHAR(10),
+      Address VARCHAR(30));
+  """
+end
+
+test_case "1 create a person" do
+  stand 0 do
+    execute """
+      INSERT INTO Person(Name, Address) VALUES('Gijs', 'Heerlen');
+    """
+    @person_id = last_insert_id
+  end
+
+  stand 1 do 
+    execute("""
+      SELECT Name, Address from Person WHERE Id = #{@person_id}
+    """).should == [
+      ['Gijs', 'Heerlen']
+    ]
+
+  end
+end
+
+test_case "silly named person" do
+  stand 0 do 
+    execute "INSERT INTO Person(Name, Address) VALUES('$%$#%$#', 'Heerlen');"
+    execute("SELECT Name FROM Person WHERE Id = '#{last_insert_id}';i").should == [ ['$%$#%$#'] ]
+  end
+end

data/lib/sql_test_runner/version.rb

@@ -0,0 +1,3 @@
+module Sqltestrunner
+  VERSION = "0.0.1"
+end

data/lib/sql_test_runner.rb

@@ -0,0 +1,152 @@
+require "sql_test_runner/version"
+
+module SqlTestRunner 
+  class Runner
+    def initialize(sql_connection, step_logger)
+      @stands = {}
+      @before_blocks = []
+      @sql_connection = sql_connection
+      @step_logger = step_logger
+    end
+
+    def run_file(test_script)
+      begin
+        run File.read(test_script)
+      rescue Errno::ENOENT => e
+        raise ScriptNotFound.new(e.message)
+      end
+    end
+
+    def run(test_description)
+      load_tests(test_description)
+      run_stands
+      step_logger.log_results
+    end
+
+    def load_tests(test_description)
+      instance_eval test_description
+    end
+
+    def add_stand(stand)
+      name = stand.name
+      stands[name] = [] unless stands[name]
+      stands[name] << stand
+    end
+
+    def before(description = "",  &block)
+      @before_blocks << BeforeAction.new(self, description, block)
+    end
+
+    def test_case(name, &block)
+      TestCase.new(self, name).instance_eval(&block)
+    end
+
+    private
+    def run_stands
+      before_blocks.each { |before_block| before_block.run(test_result, sql_connection, step_logger) }
+      stands.keys.sort.each do |key|
+        stands[key].each do |stand|
+          stand.run(test_result, sql_connection, step_logger)
+        end
+      end
+    end
+    attr_reader :sql_connection, :step_logger, :stands, :before_blocks, :test_result
+  end
+
+  class TestResult
+    def initialize(logger)
+      @logger = logger
+      @errors = []
+      @steps_count = 0
+    end
+
+    def log_step(step)
+      @last_step = step
+      @steps_count += 1
+      logger.log_step(step)
+    end
+
+    def log_error(error)
+      error = ExpectationNotMetError.new(error, @last_step)
+      logger.log_error(error)
+      @errors << error
+    end
+
+    def error_count
+      @errors.size
+    end
+
+    def log_results
+      logger.log_results(self)
+    end
+
+    def summary
+      lines = errors.map { |error| error.summary }
+      lines << "#{@steps_count} testcases - #{error_count} failures"
+      lines.join $/
+    end
+
+    attr_reader :logger, :errors
+  end
+
+  class TestCase < Struct.new(:runner, :name)
+    def stand(stand_name, &block)
+      runner.add_stand(Stand.new(self, stand_name, block))
+    end
+    def to_s
+      name
+    end
+    def description
+      "testcase #{name}"
+    end
+  end
+
+  class Step < Struct.new(:parent, :name, :block)
+    def run(test_result, sql_connection, step_logger)
+      step_logger.log_step(self)
+      begin
+        sql_connection.instance_eval(&block) if block
+      rescue RSpec::Expectations::ExpectationNotMetError => e
+        step_logger.log_error(e)
+      end
+    end
+  end
+
+  class Stand < Step
+    def description
+      "#{parent.description} - stand #{name}"
+    end
+  end
+
+  class BeforeAction < Step
+    def description
+      "before: #{name}"
+    end
+  end
+
+  class ExpectationNotMetError < Struct.new(:error, :caused_by_step)
+    def summary
+      "In #{caused_by_step.description}: #{error.message}"
+    end
+  end
+
+  class ScriptNotFound < Exception
+  end
+
+  class ReportingStepLogger 
+    def initialize(output = $stdout)
+      @output = output
+    end
+    def log_step(step)
+      @output.puts step.description
+    end
+    def log_error(error)
+      @output.puts error.summary
+    end
+    def log_results(results)
+      @output.puts "--- Done -- "
+      @output.puts "Summary:"
+      @output.puts results.summary
+    end
+  end
+end

data/lib/sqlite_connection.rb

@@ -0,0 +1,33 @@
+require 'sqlite3'
+require 'rspec/expectations'
+
+module SqlTestRunner
+  class ConnectionError < Exception
+
+  end
+
+  class SqliteConnection < Struct.new(:connection_string)
+    RSpec::Expectations::Syntax.enable_should(self)
+
+    def execute(query)
+      connection.execute(query)
+    end
+
+    def last_insert_id
+      connection.last_insert_row_id
+    end
+
+    private
+    def connection 
+      @connection ||= create_connection
+    end
+    def create_connection
+      begin
+      SQLite3::Database.open(connection_string)
+      rescue Exception => e
+        raise ConnectionError.new(e.message)
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+$: << 'lib'
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/sql_test_runner_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+require 'sql_test_runner'
+
+module SqlTestRunner
+  describe Runner do
+    let(:sql_connection) { mock('connection', :execute => nil) }
+    let(:step_logger) { mock('step_logger').as_null_object }
+    let(:result) { TestResult.new(step_logger) }
+    let(:runner) { Runner.new(sql_connection,result) }
+
+    describe "test cases" do
+      let(:sql_connection) { mock('connection') }
+
+      it "runs a stand block" do
+        sql_connection.should_receive(:execute).with("select bla from bla")
+        runner.run %Q{
+        test_case "name" do
+          stand 0 do 
+            execute "select bla from bla"
+          end
+        end
+        }
+      end
+
+
+      it "runs stand blocks of different test cases and same key in order" do
+        sql_connection.should_receive(:execute).with("first query of stand 0").ordered
+        sql_connection.should_receive(:execute).with("second query of stand 0").ordered
+        runner.run %Q{
+        test_case "name" do
+          stand 0 do 
+            execute "first query of stand 0"
+          end
+        end
+        test_case "other" do
+          stand 0 do 
+            execute "second query of stand 0"
+          end
+        end
+        }
+      end
+
+      it "runs stand blocks sorted by key" do 
+        sql_connection.should_receive(:execute).with("query for stand 0").ordered
+        sql_connection.should_receive(:execute).with("query for stand 1").ordered
+        runner.run %Q{
+        test_case "name" do
+          stand 1 do 
+            execute "query for stand 1"
+          end
+          stand 0 do 
+            execute "query for stand 0"
+          end
+        end
+        }
+      end
+
+      it "runs all sorted by key and then by test case order in file" do 
+        sql_connection.should_receive(:execute).with("query for stand 0 of test b").ordered
+        sql_connection.should_receive(:execute).with("query for stand 1 of test c").ordered
+        sql_connection.should_receive(:execute).with("query for stand 1 of test b").ordered
+        runner.run %Q{
+        test_case "test c" do
+          stand 1 do 
+            execute "query for stand 1 of test c"
+          end
+        end
+        test_case "test b" do
+          stand 0 do 
+            execute "query for stand 0 of test b"
+          end
+          stand 1 do 
+            execute "query for stand 1 of test b"
+          end
+        end
+        }
+      end
+
+      describe "before blocks" do
+        it "runs a before block outside testcases as well" do
+          sql_connection.should_receive(:execute).with("query from before block").ordered
+          sql_connection.should_receive(:execute).with("query from stand 0 of testcase name").ordered
+          runner.run %Q{
+          before do
+            execute "query from before block" 
+          end
+          test_case "name" do
+            stand 0 do 
+              execute "query from stand 0 of testcase name"
+            end
+          end
+          }
+        end
+        it "runs more before blocks outside testcases in order of appearence" do
+          sql_connection.should_receive(:execute).with("query from before block 1")
+          sql_connection.should_receive(:execute).with("query from before block 2").ordered
+          sql_connection.should_receive(:execute).with("query from stand 0 of testcase name").ordered
+          runner.run %Q{
+          before do
+            execute "query from before block 1" 
+          end
+          before do
+            execute "query from before block 2" 
+          end
+          test_case "name" do
+            stand 0 do 
+              execute "query from stand 0 of testcase name"
+            end
+          end
+          }
+
+        end
+      end
+    end
+
+    describe "logging " do
+      class SimpleLoggerToString < Struct.new(:log)
+        def log_step(step)
+          log << "#{step.description}"
+        end
+
+        def log_results(results)
+          log << results.summary
+        end
+      end
+
+      let(:step_logger) { SimpleLoggerToString.new(logged_strings) }
+      let(:logged_strings) { [] }
+
+      it "logs step" do
+        runner.run %Q{ test_case("name") { stand 0 } }
+        logged_strings.should include "testcase name - stand 0"
+      end
+
+      it "logs steps for different test cases" do
+        runner.run %Q{ 
+          test_case("name") { stand 0 } 
+          test_case("other") { stand 0 } 
+        }
+        logged_strings[0,2].should == [
+          "testcase name - stand 0",
+          "testcase other - stand 0"
+        ]
+      end
+
+      it "logs before blocks as well" do
+        runner.run %Q{ 
+          before("first") {}
+          before("second") {}
+          test_case("name") { stand 0 } 
+        }
+        logged_strings[0,3].should == [
+          "before: first",
+          "before: second",
+          "testcase name - stand 0"
+        ]
+      end
+
+      it "logs results" do
+        runner.run %Q{} 
+        logged_strings.should == ["0 testcases - 0 failures"]
+      end
+    end
+
+    describe "running a file" do
+      let(:script_name) { File.expand_path('example_script.sql', File.dirname(__FILE__)) }
+      before { create_file(script_name, 'before { execute "query" }') }
+      after { delete_file(script_name) }
+
+      it "runs the script" do
+        sql_connection.should_receive(:execute).with("query")
+        runner.run_file(script_name)
+      end
+
+      def create_file(filename, content)
+        delete_file(filename)
+        File.open(filename, "w+") { |file| file.write(content) }
+      end
+
+      def delete_file(filename)
+        File.delete(filename) if File.exists?(filename)
+      end
+    end
+
+    describe "expectations" do
+      let(:rspec_expectation_error) { create_expectation_error }
+      it "can compare stuff" do
+        runner.run %Q{ test_case("name") { stand(0) { 2.should == 2 } } }
+      end
+
+      it "failing compare does not raise exception" do
+        expect {
+          runner.run %Q{ test_case("name") { stand(0) { 2.should == 4 } } }
+        }.not_to raise_exception
+      end
+
+      it "failing compare adds error to list of errors" do
+        expect { runner.run %Q{ test_case("name") { stand(0) { 2.should == 4 } } } }.to change {result.error_count}.by(1)
+        result.errors.last.summary.should == "In testcase name - stand 0: #{rspec_expectation_error.message}"
+      end
+
+      it "failing before adds error to list of errors" do
+        expect { runner.run %Q{ before("description") { 2.should == 4 } } }.to change {result.error_count}.by(1)
+        result.errors.last.summary.should == "In before: description: #{rspec_expectation_error.message}"
+      end
+
+      def create_expectation_error 
+        begin 
+          2.should == 4
+        rescue Exception => e
+          return e
+        end
+      end
+
+    end
+
+  end
+
+  describe TestResult do
+    let(:step_logger) { mock('step_logger').as_null_object }
+    let(:result) { TestResult.new(step_logger) }
+    let(:step) { BeforeAction.new(nil, "name") }
+    let(:rspec_expectation_error) { create_expectation_error }
+    def create_expectation_error 
+      begin 
+        2.should == 4
+      rescue Exception => e
+        return e
+      end
+    end
+
+    describe "logging step" do
+
+      it "logs the step to the logger" do
+        step_logger.should_receive(:log_step).with step
+        result.log_step(step)
+      end
+      describe "and an error" do
+        it "logs the error tot the logger" do
+          step_logger.should_receive(:log_step).with step
+          step_logger.should_receive(:log_error) do |error|
+            error.summary.should == "In before: name: #{rspec_expectation_error.message}"
+          end
+          result.log_step(step)
+          result.log_error(rspec_expectation_error)
+        end
+      end
+    end
+
+    describe "logging results" do
+      it "logs itself" do
+        step_logger.should_receive(:log_results).with result
+        result.log_results
+      end
+    end
+
+    describe "summary" do
+      subject { result.summary }
+      it { should == "0 testcases - 0 failures" }
+
+      describe "when steps logged" do
+        before { result.log_step(step) }
+        it { should == "1 testcases - 0 failures" }
+
+        describe "and errors logged" do
+          before { result.log_error(rspec_expectation_error) }
+          it { should include "1 testcases - 1 failures" }
+          it { should include rspec_expectation_error.message }
+        end
+
+      end
+    end
+  end
+
+  describe ReportingStepLogger do
+    let(:output)  { StringIO.new }
+    let(:step_logger) { ReportingStepLogger.new(output) }
+    describe "logging step" do
+      it "logs the step to the output" do
+        step_logger.log_step(stub('step', :description => "message"))
+        output.string.should include "message"
+      end
+    end
+    describe "logging error" do
+      it "logs the error's summary to output" do
+        step_logger.log_error(stub('error', :summary => "message"))
+        output.string.should include "message"
+      end
+    end
+    describe "logging results" do
+      it "logs the results summary to output" do
+        step_logger.log_results(stub('results', :summary => "message"))
+        output.string.should include "message"
+      end
+    end
+  end
+
+
+end

data/spec/sqlite_connection_spec.rb

@@ -0,0 +1,51 @@
+require 'sqlite_connection'
+
+module SqlTestRunner
+  describe SqliteConnection do
+    let(:connection) { SqliteConnection.new(":memory:") }
+
+    it "can execute a query" do
+      create_person_table.should be_empty 
+    end
+
+    it "can execute a query inserting a row" do
+      create_person_table
+      expect { insert_person("Gijs", "Heerlen").should == 1 }.to change{person_count}.from([[0]]).to([[1]])
+    end
+
+    it "read a single result" do
+      create_person_table
+      insert_person("Gijs", "Heerlen")
+      connection.execute("select * from Person where Id == '1';").should == [[1, "Gijs", "Heerlen"]]
+    end
+
+    it "read specific columns" do
+      create_person_table
+      insert_person("Gijs", "Heerlen")
+      connection.execute("select Name, Address from Person where Id == '1';").first.should == ["Gijs", "Heerlen"]
+    end
+
+    describe "connection error" do
+      let(:connection) { SqliteConnection.new('bogus_dir/bogus_connection') }
+      it "throws exception" do
+        expect { create_person_table }.to raise_exception ConnectionError
+      end
+    end
+
+    def create_person_table
+      connection.execute(%Q{CREATE TABLE IF NOT EXISTS Person(
+                            Id INTEGER PRIMARY KEY,
+                            Name VARCHAR(10),
+                            Address VARCHAR(30));})
+    end
+
+    def insert_person(name, address)
+      connection.execute("INSERT INTO Person(Name, Address) VALUES('#{name}', '#{address}');")
+      connection.last_insert_id
+    end
+
+    def person_count
+      connection.execute("SELECT COUNT(*) from Person;")
+    end
+  end
+end

data/sqltestrunner.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sql_test_runner/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "sqltestrunner"
+  gem.version       = Sqltestrunner::VERSION
+  gem.authors       = ["Rob Westgeest"]
+  gem.email         = ["rob@qwan.it"]
+  gem.description   = %q{runs sqltests for CBS Testing environment}
+  gem.summary       = %q{aqltestrunner takes a _sqlt.rb file and runs the content as test
+
+  Specifically it runs blocks of testcases ordered by 'stand' blocks.
+
+  }
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency 'rspec-expectations'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'sqlite3'
+  gem.add_development_dependency 'rb-inotify', '0.8.8'
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: sqltestrunner
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rob Westgeest
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: guard-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: sqlite3
+  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: rb-inotify
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.8
+description: runs sqltests for CBS Testing environment
+email:
+- rob@qwan.it
+executables:
+- sqltestrunner
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/sqltestrunner
+- examples/creating_a_person_test.sql
+- lib/sql_test_runner.rb
+- lib/sql_test_runner/version.rb
+- lib/sqlite_connection.rb
+- spec/spec_helper.rb
+- spec/sql_test_runner_spec.rb
+- spec/sqlite_connection_spec.rb
+- sqltestrunner.gemspec
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: aqltestrunner takes a _sqlt.rb file and runs the content as test  Specifically
+  it runs blocks of testcases ordered by 'stand' blocks.
+test_files:
+- spec/spec_helper.rb
+- spec/sql_test_runner_spec.rb
+- spec/sqlite_connection_spec.rb