squcumber-postgres 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0db456e704910175875824a14312d2c5668569d8
+  data.tar.gz: 9e198d71fd8649646683b2df6be14a88e139a662
+SHA512:
+  metadata.gz: 8f9db0cd15453cd1fac71a582fd821b56f1cf51fbc22d88e1446fdf1e7673383e2617a9c769e4db6f4877b092ea165fd6e46e0c2865538711dac00ed1e0f97a1
+  data.tar.gz: 4786343ae7714bfc33bc1779008a1aaacd85dd3569f5a09c9e673e076f5c96bfd532e776fed95da0c18034c90037229e864970d55e0122697eceecb5f57486ef

data/Rakefile

@@ -0,0 +1,2 @@
+load 'lib/squcumber-postgres/tasks/test.rake'
+project_name = 'squcumber-postgres'

data/lib/squcumber-postgres.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + '/squcumber-postgres/*.rb'].each { |file| require file }

data/lib/squcumber-postgres/mock/database.rb

@@ -0,0 +1,129 @@
+require 'pg'
+
+module Squcumber
+  module Postgres
+    module Mock
+      class Database
+        DELETE_DB_WHEN_FINISHED = ENV['KEEP_TEST_DB'].to_i == 1 ? false : true
+        TEST_DB_NAME_OVERRIDE = ENV.fetch('TEST_DB_NAME_OVERRIDE', '')
+
+        def initialize(production_database)
+          @production_database = production_database or raise ArgumentError, 'No production database provided'
+
+          test_db_name_postfix = TEST_DB_NAME_OVERRIDE.empty? ? rand(10000..99999) : TEST_DB_NAME_OVERRIDE
+          @test_db_name = "test_env_#{test_db_name_postfix}"
+
+          if @production_database.exec("select datname from pg_database where datname like '%#{@test_db_name}%'").num_tuples != 0
+            @production_database.exec("drop database #{@test_db_name}")
+          end
+          @production_database.exec("create database #{@test_db_name}")
+
+          @testing_database = PG.connect(
+            host: ENV['DB_HOST'],
+            port: ENV['DB_PORT'],
+            dbname: @test_db_name,
+            user: ENV['DB_USER'],
+            password: ENV['DB_PASSWORD']
+          )
+        end
+
+        def setup(schemas)
+          schemas.each do |schema|
+            exec("drop schema if exists #{schema} cascade")
+            exec("create schema #{schema}")
+          end
+        end
+
+        def truncate_all_tables
+          @testing_database
+            .exec("select schemaname || '.' || tablename as schema_and_table from pg_tables where tableowner = '#{ENV['DB_USER']}'")
+            .map { |row| row['schema_and_table'] }
+            .each { |schema_and_table| exec("truncate table #{schema_and_table}") }
+        end
+
+        def exec(statement)
+          @testing_database.exec(statement)
+        end
+        alias_method :query, :exec
+
+        def exec_file(path)
+          exec(File.read("#{path}"))
+        end
+        alias_method :query_file, :exec_file
+
+        # Redshift does not allow to copy a table schema to another database, i.e.
+        # `create table some_db.some_table (like another_db.some_table)` cannot be used.
+        def copy_table_def_from_prod(schema, table)
+          create_table_statement = _get_create_table_statement(schema, table)
+          exec(create_table_statement)
+        end
+
+        def copy_table_defs_from_prod(tables)
+          tables.each do |obj|
+            obj.each { |schema, table| copy_table_def_from_prod(schema, table) }
+          end
+        end
+
+        def mock(mock)
+          mock.each do |schema_and_table, data|
+            raise "Mock data for #{schema_and_table} is not correctly formatted: must be Array but was #{data.class}" unless data.is_a?(Array)
+            data.each { |datum| insert_mock_values(schema_and_table, datum) }
+          end
+        end
+
+        def insert_mock_values(schema_and_table, mock)
+          schema, table = schema_and_table.split('.')
+          keys = []
+          vals = []
+          mock.each do |key, value|
+            unless value.nil?
+              keys << key
+              vals << (value.is_a?(String) ? "'#{value}'" : value)
+            end
+          end
+          exec("insert into #{schema}.#{table} (#{keys.join(',')}) values (#{vals.join(',')})") unless vals.empty?
+        end
+
+        def destroy
+          @testing_database.close()
+
+          if DELETE_DB_WHEN_FINISHED
+            attempts = 0
+            begin
+              attempts += 1
+              @production_database.exec("drop database #{@test_db_name}")
+            rescue PG::ObjectInUse
+              sleep 5
+              retry unless attempts >= 3
+            end
+          else
+            puts "\nTest database has been kept alive: #{@test_db_name}"
+          end
+
+          @production_database.close()
+        end
+
+        private
+
+        def _get_create_table_statement(schema, table)
+          @production_database.exec("set search_path to '$user', #{schema};")
+          table_schema = @production_database.query("select * from information_schema.columns where table_schema = '#{schema}' and table_name = '#{table}';")
+          raise "Sorry, there is no table information for #{schema}.#{table}" if table_schema.num_tuples == 0
+
+          definitions = _get_column_definitions(table_schema).join(',')
+
+          "create table if not exists #{schema}.#{table} (#{definitions});"
+        end
+
+        def _get_column_definitions(table_definition)
+          table_definition.map do |definition|
+            if definition['data_type'].eql?('character')
+              definition['data_type'] = "#{definition['data_type']}(#{definition['character_maximum_length'].to_s})"
+            end
+            "#{definition['column_name']} #{definition['data_type']} default null"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/squcumber-postgres/rake/task.rb

@@ -0,0 +1,51 @@
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rake'
+
+module Squcumber
+  module Postgres
+    module Rake
+      class Task
+        include ::Rake::DSL if defined? ::Rake::DSL
+
+        def install_tasks
+          namespace :test do
+            # Auto-generate Rake tasks for each feature and each of their parent directories
+            @features_dir = File.join(FileUtils.pwd, 'features')
+            features = Dir.glob("#{@features_dir}/**/*.feature")
+            parent_directories = features.map { |f| f.split('/')[0..-2].join('/') }.uniq
+
+            features.each do |feature|
+              feature_name = feature.gsub(File.join(FileUtils.pwd, 'features/'), '').gsub('.feature', '')
+              task_name = feature_name.gsub('/', ':')
+              desc "Run SQL tests for feature #{feature_name}"
+              task "sql:#{task_name}".to_sym, [:scenario_line_number] do |_, args|
+                cucumber_task_name = "cucumber_#{task_name}".to_sym
+                ::Cucumber::Rake::Task.new(cucumber_task_name) do |t|
+                  line_number = args[:scenario_line_number].nil? ? '' : ":#{args[:scenario_line_number]}"
+                  t.cucumber_opts = "#{feature}#{line_number} --format pretty --format html --out #{feature_name.gsub('/','_')}.html --require #{File.dirname(__FILE__)}/../support --require #{File.dirname(__FILE__)}/../step_definitions"
+                end
+                ::Rake::Task[cucumber_task_name].execute
+              end
+            end
+
+            parent_directories.each do |feature|
+              feature_name = feature.gsub(File.join(FileUtils.pwd, 'features/'), '').gsub('.feature', '')
+              task_name = feature_name.gsub('/', ':')
+              desc "Run SQL tests for all features in #{feature_name}"
+              task "sql:#{task_name}".to_sym do
+                cucumber_task_name = "cucumber_#{task_name}".to_sym
+                ::Cucumber::Rake::Task.new(cucumber_task_name) do |t|
+                  t.cucumber_opts = "#{feature} --format pretty --format html --out #{feature_name.gsub('/','_')}.html --require #{File.dirname(__FILE__)}/../support --require #{File.dirname(__FILE__)}/../step_definitions"
+                end
+                ::Rake::Task[cucumber_task_name].execute
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Squcumber::Postgres::Rake::Task.new.install_tasks

data/lib/squcumber-postgres/step_definitions/common_steps.rb

@@ -0,0 +1,159 @@
+require 'json'
+
+$feature_name ||= ''
+$setup ||= false
+
+Before do |scenario|
+  current_scenario_name = scenario.feature.name rescue nil
+  if current_scenario_name != $feature_name
+    $feature_name = current_scenario_name
+    $setup = false
+  end
+end
+
+# Takes a path and then sequentially adds what's provided in `data`
+# to be later executed in the step `the given SQL files are executed`
+# +path+:: relative to root of project, e.g. "jobs/kpi/sales"
+Given(/^the SQL files in the path "?([^"]*)"?:$/) do |path, data|
+  @sql_file_path = path
+  @sql_files_to_execute = data.hashes.map { |e| "#{@sql_file_path}/#{e['file']}" }
+end
+
+Given(/^the SQL file path "?([^\s"]+)"?$/) do |path|
+  @sql_file_path = path
+end
+
+Given(/^Pending: (.*)/) { |reason| pending(reason) }
+
+Given(/^their schema dependencies:$/) do |data|
+  unless $setup
+    schemas = data.hashes.map { |hash| hash['schema'] }.compact.uniq
+    TESTING_DATABASE.setup(schemas)
+  end
+end
+
+Given(/^their table dependencies:$/) do |data|
+  if $setup
+    silence_streams(STDERR) do
+      TESTING_DATABASE.truncate_all_tables()
+    end
+  else
+    tables = []
+    schemas = []
+    data.hashes.each do |hash|
+      schema, table = hash['table'].split('.')
+      schemas << schema
+      tables << { schema => table }
+    end
+    silence_streams(STDERR) do
+      TESTING_DATABASE.setup(schemas.compact.uniq)
+      TESTING_DATABASE.copy_table_defs_from_prod(tables)
+    end
+    $setup = true
+  end
+end
+
+Given(/^the following defaults for "?([^\s"]+)"? \(if not stated otherwise\):$/) do |table, data|
+  @defaults ||= {}
+  @defaults[table] = data.hashes[0]
+end
+
+Given(/a clean environment/) do
+  silence_streams(STDERR) do
+    TESTING_DATABASE.truncate_all_tables()
+  end
+end
+
+Given(/^the existing table "?([a-zA-Z0-9_]+)\.([a-zA-Z0-9_]+)"?( with date placeholders)?:$/) do |schema, table, placeholder, data|
+  mock_data = data.hashes
+  @defaults ||= {}
+  defaults = @defaults["#{schema}.#{table}"]
+
+  unless defaults.nil? or defaults.empty?
+    mock_data.map! { |entry| defaults.merge(entry) }
+  end
+
+  mock_data = convert_mock_values(mock_data) if placeholder
+
+  TESTING_DATABASE.mock(
+    Hash["#{schema}.#{table}", mock_data]
+  )
+end
+
+When(/^the given SQL files are executed$/) do
+  silence_streams(STDERR) do
+    @sql_files_to_execute.each { |file| TESTING_DATABASE.exec_file(file) }
+  end
+end
+
+When(/^the SQL file "?([^\s]+)"? is executed/) do |file|
+  silence_streams(STDERR) do
+    TESTING_DATABASE.exec_file("#{@sql_file_path}/#{file}")
+  end
+end
+
+When(/^the resulting table "?([^\s"]*)"? is queried(?:, ordered by "?([^"]*)"?)?/) do |table, sort_column|
+  sort_statement = (sort_column.nil? or sort_column.empty?) ? '' : "order by #{sort_column}"
+  @result = TESTING_DATABASE.query("select * from #{table} #{sort_statement};").map { |e| e }
+end
+
+Then(/^the result starts with.*$/) do |data|
+  actual = @result[0..(data.hashes.length - 1)] || []
+  expected = data.hashes || []
+
+  expected.each_with_index do |hash, i|
+    raise("Does not start with expected result, got:\n#{format_error(data, actual)}") unless actual[i].all? do |key, value|
+      values_match(value, hash[key]) # actual,expected
+    end
+  end
+end
+
+Then(/^the result includes.*$/) do |data|
+  actual = @result || []
+  expected = data.hashes || []
+
+  expected.each do |hash|
+    raise("Result is not included, got:\n#{format_error(data, actual)}") unless actual.any? do |row|
+      row.all? do |key, value|
+        values_match(value, hash[key]) # actual,expected
+      end
+    end
+  end
+end
+
+Then(/^the result does not include.*$/) do |data|
+  actual = @result || []
+  expected = data.hashes || []
+
+  expected.each do |hash|
+    raise("Result is included, got:\n#{format_error(data, actual)}") if actual.any? do |row|
+      row.all? do |key, value|
+        values_match(value, hash[key]) # actual,expected
+      end
+    end
+  end
+end
+
+Then(/^the result exactly matches.*$/) do |data|
+  actual = @result || []
+  expected = data.hashes || []
+
+  raise("Does not match exactly, got:\n#{format_error(data, actual)}") if actual.length != expected.length
+
+  actual.each_with_index do |row, i|
+    raise("Does not match exactly, got:\n#{format_error(data, actual)}") unless (expected[i] || {}).all? do |key, value|
+      values_match(row[key], value) # actual,expected
+    end
+  end
+
+  expected.each_with_index do |hash, i|
+    raise("Does not match exactly, got:\n#{format_error(data, actual)}") unless (actual[i] || {}).all? do |key, value|
+      values_match(value, hash[key]) # actual,expected
+    end
+  end
+end
+
+Then(/^the result is empty.*$/) do
+  actual = @result || []
+  raise("Result is not empty, got:\n#{format_error({}, actual)}") unless actual.length == 0
+end

data/lib/squcumber-postgres/support/database.rb

@@ -0,0 +1,17 @@
+require_relative '../mock/database'
+
+print 'Connect to production database...'
+production_database = PG.connect(
+  host: ENV['DB_HOST'],
+  port: ENV['DB_PORT'],
+  dbname: ENV['DB_NAME'],
+  user: ENV['DB_USER'],
+  password: ENV['DB_PASSWORD']
+)
+puts 'DONE.'
+
+TESTING_DATABASE ||= Squcumber::Postgres::Mock::Database.new(production_database)
+
+at_exit do
+  TESTING_DATABASE.destroy rescue nil
+end

data/lib/squcumber-postgres/support/matchers.rb

@@ -0,0 +1,45 @@
+module MatcherHelpers
+  def values_match(actual, expected)
+    if expected.eql?('today')
+      actual.match(/#{Regexp.quote(Date.today.to_s)}/)
+    elsif expected.eql?('yesterday')
+      actual.match(/#{Regexp.quote((Date.today - 1).to_s)}/)
+    elsif expected.eql?('any_date')
+      actual.match(/^\d{4}\-\d{2}\-\d{2} \d{2}:\d{2}:\d{2}$/)
+    elsif expected.eql?('any_string')
+      true if actual.is_a?(String) or actual.nil?
+    elsif expected.eql?('false') or expected.eql?('true')
+      true if actual.eql?(expected[0])
+    elsif !expected.nil?
+      actual ||= ''
+      actual.eql?(expected)
+    else  # we have not mocked this, so ignore it
+      true
+    end
+  end
+
+  def timetravel(date, i, method); i > 0 ? timetravel(date.send(method.to_sym), i - 1, method) : date; end
+
+  def convert_mock_values(mock_data)
+    mock_data.map do |entry|
+      entry.each do |key, value|
+        entry[key] = case value
+          when /today/
+            Date.today.to_s
+          when /yesterday/
+            Date.today.prev_day.to_s
+          when /\s*\d+\s+month(s)?\s+ago\s*/
+            number_of_months = value.match(/\d+/)[0].to_i
+            timetravel(Date.today, number_of_months, :prev_month).to_s
+          when /\s*\d+\s+day(s)?\s+ago\s*/
+            number_of_days = value.match(/\d+/)[0].to_i
+            timetravel(Date.today, number_of_days, :prev_day).to_s
+          else
+            value
+        end
+      end
+    end
+  end
+end
+
+World(MatcherHelpers)

data/lib/squcumber-postgres/support/output.rb

@@ -0,0 +1,43 @@
+module OutputHelpers
+  def silence_streams(*streams)
+    unless ENV['SHOW_STDOUT'].to_i == 1
+      begin
+        on_hold = streams.collect { |stream| stream.dup }
+        streams.each do |stream|
+          stream.reopen('/dev/null')
+          stream.sync = true
+        end
+        yield
+      ensure
+        streams.each_with_index do |stream, i|
+          stream.reopen(on_hold[i])
+        end
+      end
+    end
+  end
+
+  def format_error(expected_data, actual_result)
+    expectation_count = (expected_data.rows.count rescue nil) || 0
+    if expectation_count == 0
+      table_headings = actual_result[0].keys
+    else
+      table_headings = expected_data.hashes[0].keys
+    end
+    print_data = Hash[table_headings.map { |key| [key, key.length] }]
+
+    actual_result.each do |row|
+      row.each do |key, value|
+        print_data[key] = value.length if (value.to_s.length > print_data[key].to_i)
+      end
+    end
+
+    error = '| ' + table_headings.map { |k| k.ljust(print_data[k], ' ') }.join(' | ') + " |\n"
+    error << actual_result.map do |row|
+      '| ' + table_headings.map { |k| (row[k] || '').ljust(print_data[k], ' ') }.join(' | ') + ' |'
+    end.join("\n") + "\n"
+
+    error
+  end
+end
+
+World(OutputHelpers)

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'rspec/collection_matchers'
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+RSpec.configure do |config|
+  config.color = true
+
+  # Redirect stderr and stdout to get rid of info messages during execution
+  # of specs.
+  # Via http://stackoverflow.com/questions/15430551/suppress-console-output-during-rspec-tests
+  unless ENV['SPEC_SHOW_STDOUT'] == '1'
+    original_stderr = $stderr
+    original_stdout = $stdout
+    config.before(:all) do
+      $stderr = File.new('/dev/null', 'w')
+      $stdout = File.new('/dev/null', 'w')
+    end
+    config.after(:all) do
+      $stderr = original_stderr
+      $stdout = original_stdout
+    end
+  end
+end
+
+# Via https://www.relishapp.com/rspec/rspec-core/docs/example-groups/shared-examples
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }

data/spec/squcumber-postgres/mock/database_spec.rb

@@ -0,0 +1,447 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/squcumber-postgres/mock/database'
+
+module Squcumber::Postgres::Mock
+  describe Database do
+    let(:production_database) { double(PG::Connection) }
+    let(:testing_database)    { double(PG::Connection) }
+
+    let(:empty_result)     { double(PG::Result) }
+    let(:non_empty_result) { double(PG::Result) }
+
+    before(:each) do
+      allow(ENV).to receive(:[]).with('DB_HOST').and_return('some.db.host')
+      allow(ENV).to receive(:[]).with('DB_PORT').and_return(1234)
+      allow(ENV).to receive(:[]).with('DB_USER').and_return('some_user')
+      allow(ENV).to receive(:[]).with('DB_PASSWORD').and_return('s0m3_p4ssw0rd')
+      allow(ENV).to receive(:[]).with('DB_NAME').and_return('some_db')
+
+      allow(PG).to receive(:connect).and_return(testing_database)
+      allow(production_database).to receive(:exec).with(/^\s*create\s+database\s+/)
+      allow(production_database).to receive(:exec).with(/^\s*select\s+datname\s+from\s+pg_database\s+/).and_return(empty_result)
+      allow(production_database).to receive(:exec).with(/^\s*set\s+search_path\s+to\s+/)
+      allow(production_database).to receive(:exec).with(/^\s*drop\s+database\s+/)
+      allow(testing_database).to receive(:exec)
+
+      allow(empty_result).to receive(:num_tuples).and_return(0)
+      allow(non_empty_result).to receive(:num_tuples).and_return(1)
+    end
+
+    describe '#initialize' do
+      context 'when all arguments are provided' do
+        context 'and the database does not exist' do
+          it 'does not raise an error' do
+            expect { described_class.new(production_database) }.to_not raise_error
+          end
+
+          it 'generates a testing database name with expected pattern' do
+            dummy = described_class.new(production_database)
+            expect(dummy.instance_variable_get(:@test_db_name)).to match(/^test_env_\d{5}$/)
+          end
+
+          it 'does not try to drop the database' do
+            described_class.new(production_database)
+            expect(production_database).to_not have_received(:exec).with(/^drop\s+database\s+/)
+          end
+
+          it 'creates the testing database' do
+            dummy = described_class.new(production_database)
+            test_db_name = dummy.instance_variable_get(:@test_db_name)
+            expect(production_database).to have_received(:exec).with(/^\s*create\s+database\s+#{Regexp.quote(test_db_name)}\s*;?\s*$/)
+          end
+
+          it 'connects to testing database in correct order with correct attributes' do
+            dummy = described_class.new(production_database)
+
+            test_db_name = dummy.instance_variable_get(:@test_db_name)
+            expect(production_database).to have_received(:exec).with(/^\s*create\s+database\s+#{Regexp.quote(test_db_name)}\s*;?\s*$/).ordered
+
+            expect(PG).to have_received(:connect).with(
+              host: 'some.db.host',
+              port: 1234,
+              dbname: test_db_name,
+              user: 'some_user',
+              password: 's0m3_p4ssw0rd'
+            ).ordered
+          end
+        end
+
+        context 'and the database name is being overridden' do
+          let(:testing_db_name) { 'some_db_name' }
+
+          before(:each) do
+            stub_const("#{described_class}::TEST_DB_NAME_OVERRIDE", testing_db_name)
+          end
+
+          it 'does not raise an error' do
+            expect { described_class.new(production_database) }.to_not raise_error
+          end
+
+          it 'generates a testing database name with expected pattern' do
+            dummy = described_class.new(production_database)
+            expect(dummy.instance_variable_get(:@test_db_name)).to match(/^test_env_#{Regexp.quote(testing_db_name)}$/)
+          end
+
+          it 'does not try to drop the database' do
+            described_class.new(production_database)
+            expect(production_database).to_not have_received(:exec).with(/^drop\s+database\s+/)
+          end
+
+          it 'creates the testing database' do
+            described_class.new(production_database)
+            expect(production_database).to have_received(:exec).with(/^\s*create\s+database\s+test_env\_#{Regexp.quote(testing_db_name)}\s*;?\s*$/)
+          end
+
+          it 'connects to testing database in correct order with correct attributes' do
+            described_class.new(production_database)
+            expect(production_database).to have_received(:exec).with(/^\s*create\s+database\s+test_env_#{Regexp.quote(testing_db_name)}\s*;?\s*$/).ordered
+
+            expect(PG).to have_received(:connect).with(
+              host: 'some.db.host',
+              port: 1234,
+              dbname: 'test_env_' + testing_db_name,
+              user: 'some_user',
+              password: 's0m3_p4ssw0rd'
+            ).ordered
+          end
+        end
+
+        context 'and the database already exists' do
+          before(:each) do
+            allow(production_database).to receive(:exec).with(/^select\s+datname\s+from\s+pg_database\s+/).and_return(non_empty_result)
+          end
+
+          it 'does not raise an error' do
+            expect { described_class.new(production_database) }.to_not raise_error
+          end
+
+          it 'generates a testing database name with expected pattern' do
+            dummy = described_class.new(production_database)
+            expect(dummy.instance_variable_get(:@test_db_name)).to match(/^test_env_\d{5}$/)
+          end
+
+          it 'drops the existing testing database' do
+            described_class.new(production_database)
+            expect(production_database).to have_received(:exec).with(/^drop\s+database\s+/)
+          end
+
+          it 'creates the testing database' do
+            dummy = described_class.new(production_database)
+            test_db_name = dummy.instance_variable_get(:@test_db_name)
+            expect(production_database).to have_received(:exec).with(/^\s*create\s+database\s+#{Regexp.quote(test_db_name)}\s*;?\s*$/)
+          end
+
+          it 'connects to testing database in correct order with correct attributes' do
+            dummy = described_class.new(production_database)
+
+            test_db_name = dummy.instance_variable_get(:@test_db_name)
+            expect(production_database).to have_received(:exec).with(/^\s*create\s+database\s+#{Regexp.quote(test_db_name)}\s*;?\s*$/).ordered
+
+            expect(PG).to have_received(:connect).with(
+              host: 'some.db.host',
+              port: 1234,
+              dbname: test_db_name,
+              user: 'some_user',
+              password: 's0m3_p4ssw0rd'
+            ).ordered
+          end
+        end
+      end
+
+      context 'when some arguments are missing' do
+        it 'raises an error when production database is not provided' do
+          expect { described_class.new(nil) }.to raise_error(ArgumentError, 'No production database provided')
+        end
+      end
+    end
+
+    describe '#setup' do
+      let(:schemas) { ['some_schema', 'another_schema'] }
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+        allow(@dummy).to receive(:exec)
+        @dummy.setup(schemas)
+      end
+
+      it 'drops and creates all schemas' do
+        expect(@dummy).to have_received(:exec).with('drop schema if exists some_schema cascade').ordered
+        expect(@dummy).to have_received(:exec).with('create schema some_schema').ordered
+        expect(@dummy).to have_received(:exec).with('drop schema if exists another_schema cascade').ordered
+        expect(@dummy).to have_received(:exec).with('create schema another_schema').ordered
+      end
+    end
+
+    describe '#truncate_all_tables' do
+      let(:existing_tables) { ['some_schema.some_table', 'some_other_schema.some_other_table'] }
+
+      before(:each) do
+        allow(testing_database).to receive_message_chain(:exec, :map).and_return(existing_tables)
+        @dummy = described_class.new(production_database)
+        @dummy.truncate_all_tables()
+      end
+
+      it 'asks the testing database for currently existing tables in production schemas' do
+        expect(testing_database).to have_received(:exec).with(/^\s*select\s+schemaname\s+\|\|\s+'\.'\s+\|\|\s+tablename\s+as schema\_and\_table\s+from\s+pg_tables\s+where\s+tableowner\s*=\s*'some_user'\s*;?\s*$/)
+      end
+
+      it 'truncates the returned tables in the testing database' do
+        expect(testing_database).to have_received(:exec).with(/^\s*select\s+/).ordered
+        expect(testing_database).to have_received(:exec).with(/^\s*truncate\s+table\s+some\_schema\.some\_table\s*;?\s*$/).ordered
+        expect(testing_database).to have_received(:exec).with(/^\s*truncate\s+table\s+some\_other\_schema\.some\_other\_table\s*;?\s*$/).ordered
+      end
+
+      it 'does not truncate anything in the production database' do
+        expect(production_database).to_not have_received(:exec).with(/truncate/)
+      end
+    end
+
+    describe '#exec' do
+      let(:some_statement) { 'some statement' }
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+      end
+
+      it 'executes the passed statement on the testing database' do
+        @dummy.exec(some_statement)
+        expect(testing_database).to have_received(:exec).with(some_statement)
+      end
+
+      it 'does not execute the passed statement on the production database' do
+        @dummy.exec(some_statement)
+        expect(production_database).to_not have_received(:exec).with(some_statement)
+      end
+
+      it 'sets an alias for \'query\'' do
+        expect(@dummy).to respond_to(:query)
+        @dummy.query(some_statement)
+        expect(testing_database).to have_received(:exec).with(some_statement)
+      end
+    end
+
+    describe '#exec_file' do
+      let(:some_file_path) { 'some/file/path' }
+      let(:some_file_content) { 'some file content' }
+
+      before(:each) do
+        allow(File).to receive(:read).with(some_file_path).and_return(some_file_content)
+        @dummy = described_class.new(production_database)
+      end
+
+      it 'reads the statement from the path provided, relative to root' do
+        @dummy.exec_file(some_file_path)
+        expect(File).to have_received(:read).with(some_file_path)
+      end
+
+      it 'executes the file content on the testing database' do
+        @dummy.exec_file(some_file_path)
+        expect(testing_database).to have_received(:exec).with(some_file_content)
+      end
+
+      it 'does not execute file content on the production database' do
+        @dummy.exec_file(some_file_path)
+        expect(production_database).to_not have_received(:exec).with(some_file_content)
+      end
+
+      it 'sets an alias for \'query_file\'' do
+        expect(@dummy).to respond_to(:query_file)
+        @dummy.query_file(some_file_path)
+        expect(testing_database).to have_received(:exec).with(some_file_content)
+      end
+    end
+
+    describe '#insert_mock_values' do
+      let(:table) { 'some_schema.some_table' }
+      let(:mock) do
+        {
+          'some_column' => 'some_value',
+          'some_other_column' => 1234
+        }
+      end
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+        @dummy.insert_mock_values(table, mock)
+      end
+
+      it 'transforms a given hash to an \'insert\' statement' do
+        expect(testing_database).to have_received(:exec).with(/^\s*insert\s+into\s+some\_schema\.some\_table\s+\(some\_column,some\_other\_column\)\s+values\s*\('some\_value',1234\)\s*;?\s*$/)
+      end
+
+      it 'does not try to insert anything into a production table' do
+        expect(production_database).to_not have_received(:exec).with(/insert/)
+      end
+    end
+
+    describe '#mock' do
+      let(:mock) do
+        {
+          'some_schema.some_table' => [
+            { 'some_column' => 'some_value', 'some_other_column' => 'some_other_value' },
+            { 'some_column' => 'another_value', 'some_other_column' => 'yet_another_value' }
+          ],
+          'some_other_schema.some_other_table' => [
+            { 'another_column' => 'some_value' }
+          ]
+        }
+      end
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+        allow(@dummy).to receive(:insert_mock_values)
+        @dummy.mock(mock)
+      end
+
+      it 'inserts the mock values' do
+        expect(@dummy).to have_received(:insert_mock_values).with('some_schema.some_table', { 'some_column' => 'some_value', 'some_other_column' => 'some_other_value' }).ordered
+        expect(@dummy).to have_received(:insert_mock_values).with('some_schema.some_table', { 'some_column' => 'another_value', 'some_other_column' => 'yet_another_value' }).ordered
+        expect(@dummy).to have_received(:insert_mock_values).with('some_other_schema.some_other_table', { 'another_column' => 'some_value'}).ordered
+      end
+    end
+
+    describe '#copy_table_defs_from_prod' do
+      let(:tables) { [{'some_schema' => 'some_table'}, {'some_other_schema' => 'some_other_table'}] }
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+        allow(@dummy).to receive(:copy_table_def_from_prod)
+        @dummy.copy_table_defs_from_prod(tables)
+      end
+
+      it 'triggers copies the individual table definitions from production' do
+        expect(@dummy).to have_received(:copy_table_def_from_prod).with('some_schema', 'some_table').ordered
+        expect(@dummy).to have_received(:copy_table_def_from_prod).with('some_other_schema', 'some_other_table').ordered
+      end
+    end
+
+    describe '#copy_table_def_from_prod' do
+      let(:schema) { 'some_schema' }
+      let(:table) { 'some_table' }
+      let(:some_table_definition) { 'some table definition' }
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+        allow(@dummy).to receive(:_get_create_table_statement).and_return(some_table_definition)
+        @dummy.copy_table_def_from_prod(schema, table)
+      end
+
+      it 'retrieves the table definition' do
+        expect(@dummy).to have_received(:_get_create_table_statement).with(schema, table)
+      end
+
+      it 'executes the retrieved table definition on the testing database' do
+        expect(testing_database).to have_received(:exec).with(some_table_definition)
+      end
+    end
+
+    describe '#_get_create_table_statement' do
+      let(:schema) { 'some_schema' }
+      let(:table) { 'some_table' }
+      let(:table_definition) do
+        [
+          {'table_schema' => 'some_schema', 'table_name' => 'some_table', 'column_name' => 'some_column',        'data_type' => 'integer',                'is_nullable' => 'YES'},
+          {'table_schema' => 'some_schema', 'table_name' => 'some_table', 'column_name' => 'some_other_column',  'data_type' => 'character varying(255)', 'is_nullable' => 'YES'},
+          {'table_schema' => 'some_schema', 'table_name' => 'some_table', 'column_name' => 'yet_another_column', 'data_type' => 'character(5)',           'is_nullable' => 'NO'}
+        ]
+      end
+
+      before(:each) do
+        @dummy = described_class.new(production_database)
+      end
+
+      context 'in any case' do
+        before(:each) do
+          allow(production_database).to receive(:query).and_return(table_definition)
+          @dummy.send(:_get_create_table_statement, schema, table) rescue nil
+        end
+
+        it 'sets the search path and queries the table definition' do
+          expect(production_database).to have_received(:exec).with(/^\s*set search\_path\s+to\s+'\$user',\s*some\_schema\s*;\s*$/).ordered
+          expect(production_database).to have_received(:query).with(/^\s*select\s+\*\s+from\s+information\_schema\.columns\s+where\s+table\_schema\s*=\s*'some\_schema'\s+and\s+table\_name\s*=\s*'some\_table'\s*;\s*$/).ordered
+        end
+      end
+
+      context 'when there is a table definition' do
+        before(:each) do
+          allow(production_database).to receive(:query).and_return(table_definition)
+          allow(table_definition).to receive(:num_tuples).and_return(1)
+        end
+
+        it 'does not raise an error' do
+          expect { @dummy.send(:_get_create_table_statement, schema, table) }.to_not raise_error
+        end
+
+        it 'returns a correctly parsed schema' do
+          expect(@dummy.send(:_get_create_table_statement, schema, table)).to match(
+            /^\s*create\s+table\s+if\s+not\s+exists\s+some\_schema\.some\_table\s+\(\s*some\_column\s+integer\s+(not|default)\s+null\s*,\s*some\_other\_column\s+character\s+varying\(255\)\s+(not|default)\s+null\s*,\s*yet\_another\_column\s+character\(5\)\s+(not|default)\s+null\)\s*;\s*$/
+          )
+        end
+
+        it 'returns the parsed schema with all columns allowing null values' do
+          expect(@dummy.send(:_get_create_table_statement, schema, table)).to match(
+            /^\s*create\s+table\s+if\s+not\s+exists\s+some\_schema\.some\_table\s+\(\s*some\_column\s+integer\s+default\s+null\s*,\s*some\_other\_column\s+character\s+varying\(255\)\s+default\s+null\s*,\s*yet\_another\_column\s+character\(5\)\s+default\s+null\)\s*;\s*$/
+          )
+        end
+      end
+
+      context 'when there is no table definition' do
+        before(:each) do
+          allow(production_database).to receive(:query).and_return(table_definition)
+          allow(table_definition).to receive(:num_tuples).and_return(0)
+        end
+
+        it 'raises an error' do
+          expect { @dummy.send(:_get_create_table_statement, schema, table) }.to raise_error(RuntimeError, /^Sorry, there is no table information/)
+        end
+      end
+    end
+
+    describe '#destroy' do
+      before(:each) do
+        allow(production_database).to receive(:close)
+        allow(testing_database).to receive(:close)
+        @dummy = described_class.new(production_database)
+      end
+
+      context 'when the db shall be kept' do
+        before(:each) do
+          stub_const("#{described_class}::DELETE_DB_WHEN_FINISHED", false)
+          @dummy.destroy()
+        end
+
+        it 'closes the connection to the production database' do
+          expect(production_database).to have_received(:close)
+        end
+
+        it 'closes the connection to the testing database' do
+          expect(testing_database).to have_received(:close)
+        end
+
+        it 'does not drop the testing database' do
+          expect(production_database).to_not have_received(:exec).with(/^drop\s+database/)
+        end
+      end
+
+      context 'when the db may be deleted' do
+        before(:each) do
+          stub_const("#{described_class}::DELETE_DB_WHEN_FINISHED", true)
+          @dummy.destroy()
+        end
+
+        it 'closes the connection to the production database' do
+          expect(production_database).to have_received(:close)
+        end
+
+        it 'closes the connection to the testing database' do
+          expect(testing_database).to have_received(:close)
+        end
+
+        it 'does not drop the testing database' do
+          expect(production_database).to have_received(:exec).with(/^create\s+database\s+#{Regexp.quote(@dummy.instance_variable_get(:@test_db_name))}/).ordered
+          expect(production_database).to have_received(:exec).with(/^drop\s+database\s+#{Regexp.quote(@dummy.instance_variable_get(:@test_db_name))}$/).ordered
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: squcumber-postgres
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stefanie Grunwald
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.16'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.16'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: 
+email: steffi@physics.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/squcumber-postgres.rb
+- lib/squcumber-postgres/mock/database.rb
+- lib/squcumber-postgres/rake/task.rb
+- lib/squcumber-postgres/step_definitions/common_steps.rb
+- lib/squcumber-postgres/support/database.rb
+- lib/squcumber-postgres/support/matchers.rb
+- lib/squcumber-postgres/support/output.rb
+- spec/spec_helper.rb
+- spec/squcumber-postgres/mock/database_spec.rb
+homepage: https://github.com/moertel/sQucumber-postgres
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.3
+signing_key: 
+specification_version: 3
+summary: Define and execute SQL integration tests for AWS postgres
+test_files:
+- spec/spec_helper.rb
+- spec/squcumber-postgres/mock/database_spec.rb