slacker 0.0.1

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    slacker (0.0.1)
+      rspec (= 2.5.0)
+      ruby-odbc (= 0.99994)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    ruby-odbc (0.99994)
+
+PLATFORMS
+  x86-mingw32
+
+DEPENDENCIES
+  slacker!

data/LICENSE

@@ -0,0 +1,3 @@
+== slacker
+
+Put appropriate LICENSE for your project here.

data/README.markdown

@@ -0,0 +1,16 @@
+# Slacker
+Behavior Driven Development for SQL Server
+
+# Description
+__Slacker__ is a Ruby (RSpec-based) framework for developing automated tests for SQL Server programmable objects such as stored procedures and scalar/table functions.
+
+# Install
+    gem install slacker
+
+__Slacker__ automatically installs the following gems:
+
+* rspec 2.5.0
+* ruby-odbc 0.99994
+
+__Slacker__ runs on Windows and Linux.<br/>
+Before installing __Slacker__ on Windows, you need to install the Windows DevKit (ruby-odbc contains native extensions).

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rubygems/package_task'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.fail_on_error = false
+  t.pattern = 'spec/**/*.rb'
+end

data/bin/slacker

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'slacker'
+require 'yaml'
+require 'slacker/command_line_formatter'
+
+def db_config_from_file(file_path)
+  dbconfig = nil
+  File.open(file_path) do |dbconfig_file|
+    dbconfig = YAML::load(dbconfig_file)
+  end
+  dbconfig
+end
+
+# Preset the application to run on the console
+Slacker.configure do |config|
+  config.console_enabled = true
+  config.formatter = Slacker::CommandLineFormatter.new($stdout)
+
+  # Setup the target connection based on the contents in database.yml
+  db_config = db_config_from_file(config.expand_path('database.yml'))
+
+  config.db_server = db_config["server"]
+  config.db_name = db_config["database"]
+  config.db_user = db_config["user"]
+  config.db_password = db_config["password"]
+end
+
+Slacker.application.run

data/lib/slacker.rb

@@ -0,0 +1,138 @@
+require "slacker/version"
+require 'slacker/application'
+require 'slacker/configuration'
+require 'slacker/sql'
+require 'slacker/formatter'
+require 'csv'
+require 'erb'
+
+module Slacker
+  class << self
+    def application
+      @application ||= Slacker::Application.new(configuration)
+    end
+
+    def sql(rspec_ext)
+      Slacker::Sql.new(configuration.expand_path('sql'), rspec_ext)
+    end
+
+    def configuration
+      @configuration ||= Slacker::Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def sql_template_path_stack
+      if @sql_template_path_stack.nil?
+        @sql_template_path_stack = []
+        @sql_template_path_stack.push(configuration.expand_path('sql'))
+      end
+      @sql_template_path_stack
+    end
+
+    # Given a template name produce the path to that template
+    def get_sql_template_path(template_name)
+      template_base_dir = template_name[0].chr == '/' ? sql_template_path_stack.first : sql_template_path_stack.last
+      File.expand_path(template_base_dir + '/' + template_name)
+    end
+
+    # Render a template file and return the result
+    def render(template_name, options = {})
+      template_file_path = get_sql_template_path(template_name)
+
+      if !File.exists?(template_file_path)
+        raise "File #{template_file_path} does not exist"
+      end
+
+      begin
+        sql_template_path_stack.push(File.dirname(template_file_path))
+        result = render_text(IO.read(template_file_path), options)
+      rescue => detail
+        # Report errors in the template
+        if detail.backtrace[0] =~ /^\(erb\)/
+          raise "Template error in #{template_name}:\n#{detail.backtrace[0]} : #{detail.message}\n"
+        else
+          raise detail
+        end
+      ensure
+        sql_template_path_stack.pop
+      end
+
+      result
+    end
+
+    # Render a template test and return the result
+    def render_text(template_text, options)
+      ERB.new(template_text, 0, '%<>').result(binding)
+    end
+
+    def filter_golden_master(golden_master)
+      golden_master = case golden_master
+      when String
+        golden_master =~ /\.csv$/ ? get_csv(golden_master) : golden_master
+      else
+        golden_master
+      end
+    end
+
+    def sql_from_query_string(query_string, options = {})
+      case query_string
+      when /\.sql$/i,/\.erb$/i
+        #Pass the file through an ERb template engine
+        render(query_string, options)
+      else
+        query_string
+      end
+    end
+
+    def get_csv(csv_file_path)
+      CSV.read(configuration.expand_path("data/#{csv_file_path}"), {:headers => true, :encoding => 'Windows-1252', :header_converters => :symbol})
+    end
+
+    def hash_array_to_csv(raw_array)
+      csv_array = []
+      raw_array.each do |raw_row|
+        csv_array << CSV::Row.new(raw_row.keys, raw_row.values)
+      end
+      CSV::Table.new(csv_array)
+    end
+
+    def sql_file_from_method_name(base_folder, method_name)
+      file_name = File.join(base_folder, method_name)
+
+      file_name = case
+      when File.exists?("#{file_name}.sql") then "#{file_name}.sql"
+      when File.exists?("#{file_name}.sql.erb") then "#{file_name}.sql.erb"
+      else nil
+      end
+
+      file_name.nil? ? nil : file_name.gsub(/#{Regexp.escape(configuration.expand_path('sql'))}/i, '')
+    end
+
+    def construct_log_name(entry_point, query_string, options)
+      "#{entry_point} '#{query_string}'" + (options.empty? ? '': ", options = #{options.inspect}")
+    end
+
+    # Run a SQL query against an example
+    def query_script(example, sql, log_name=nil)
+      log_name ||= 'Run SQL Script'
+      example.metadata[:sql] += ((example.metadata[:sql] == '' ? '' : "\n\n") + "-- #{log_name}\n#{sql}")
+      application.query_script(sql)
+    end
+
+    def load_csv(example, csv, table_name, log_name = nil)
+      csv_a = csv.to_a
+      sql = nil
+      csv_a.each_with_index do |row, index|
+        if index == 0
+          sql = "INSERT INTO #{table_name}(#{row.map{|header| "[#{header}]"}.join(',')})"
+        else
+          sql += ("\nSELECT #{row.map{|val| val.nil? ? 'NULL': "'#{val}'"}.join(',')}" + (index < (csv_a.count - 1) ? ' UNION ALL' : ''))
+        end
+      end
+      query_script(example, sql, log_name) unless sql.nil?
+    end
+  end
+end

data/lib/slacker/application.rb

@@ -0,0 +1,201 @@
+require 'logger'
+require 'rspec/core'
+require 'slacker/rspec_monkey'
+require 'slacker/rspec_ext'
+require 'slacker/string_helper'
+require 'odbc'
+
+module Slacker
+  class Application
+    attr_reader :target_folder_structure
+
+    SQL_OPTIONS = <<EOF
+set textsize 2147483647;
+set language us_english;
+set dateformat mdy;
+set datefirst 7;
+set lock_timeout -1;
+set quoted_identifier on;
+set arithabort on;
+set ansi_null_dflt_on on;
+set ansi_warnings on;
+set ansi_padding on;
+set ansi_nulls on;
+set concat_null_yields_null on;
+EOF
+
+    def initialize(configuration)
+      @configuration = configuration
+      @target_folder_structure = ['data', 'debug', 'debug/passed_examples', 'debug/failed_examples', 'sql', 'spec', 'lib', 'lib/helpers']
+      @error_message = ''
+      @database = ODBC::Database.new
+    end
+
+    def print_connection_message
+      puts "#{@configuration.db_name} (#{@configuration.db_server})" if @configuration.console_enabled
+    end
+
+    # Customize RSpec and run it
+    def run
+      begin
+        error = catch :error_exit do
+          print_connection_message
+          test_folder_structure
+          cleanup_folders
+          configure
+          run_rspec
+          false #Return false to error
+        end
+      ensure
+        cleanup_after_run
+      end
+
+      if @configuration.console_enabled
+        puts @error_message if error
+      else
+        raise @error_message if error
+      end
+    end
+
+    def run_rspec
+      RSpec::Core::Runner.disable_autorun!
+
+      RSpec::Core::Runner.run(@configuration.rspec_args,
+        @configuration.error_stream,
+        @configuration.output_stream)
+    end
+
+    # Configure Slacker
+    def configure
+      configure_db
+      configure_rspec
+      configure_misc
+    end
+
+    def cleanup_after_run
+      @database.disconnect if (@database && @database.connected?)
+    end
+
+    def cleanup_folders
+      cleanup_folder('debug/passed_examples')
+      cleanup_folder('debug/failed_examples')
+    end
+
+    def cleanup_folder(folder)
+      folder_path = get_path(folder)
+      Dir.new(folder_path).each{|file_name| File.delete("#{folder_path}/#{file_name}") if File.file?("#{folder_path}/#{file_name}")}
+    end
+
+    # Get a path relative to the current path
+    def get_path(path)
+      @configuration.expand_path(path)
+    end
+
+    def configure_misc
+      # Add the lib folder to the load path
+      $:.push get_path('lib')
+      # Mixin the helper modules
+      mixin_helpers
+    end
+
+    # Mix in the helper modules
+    def mixin_helpers
+      helpers_dir = get_path('lib/helpers')
+      $:.push helpers_dir
+      Dir.new(helpers_dir).each do |file_name|
+        if file_name =~ /\.rb$/
+          require file_name
+          RSpec.configure do |config|
+            config.include(Slacker::StringHelper.constantize(Slacker::StringHelper.camelize(file_name.gsub(/\.rb$/,''))))
+          end
+        end
+      end
+    end
+
+    # Configure database connection
+    def configure_db
+      drv = ODBC::Driver.new
+      drv.name = 'Driver1'
+      drv.attrs.tap do |a|
+        a['Driver'] = '{SQL Server}'
+        a['Server']= @configuration.db_server
+        a['Database']= @configuration.db_name
+        a['Uid'] = @configuration.db_user
+        a['Pwd'] = @configuration.db_password
+        a['TDS_Version'] = '7.0' #Used by the linux driver
+      end
+
+      @database.drvconnect(drv)
+    end
+
+    # Run a script against the currently configured database
+    def query_script(sql)
+      results = []
+      begin
+        st = @database.run(sql)
+        begin
+          if st.ncols > 0
+            rows = []
+            st.each_hash(false, true){|row| rows << row}
+            results << rows
+          end
+        end while(st.more_results)
+      ensure
+        st.drop unless st.nil?
+      end
+      results.count > 1 ? results : results.first
+    end
+
+    # Customize RSpec
+    def configure_rspec
+      before_proc = lambda do |example|
+        # Initialize the example's SQL
+        example.metadata[:sql] = ''
+        Slacker.query_script(example, 'begin transaction;', 'Initiate the example script')
+        Slacker.query_script(example, SQL_OPTIONS, 'Set default options')
+      end
+
+      after_proc = lambda do |example|
+        Slacker.query_script(example, 'rollback transaction;', 'Rollback the changes made by the example script')
+      end
+
+      # Reset RSpec through a monkey-patched method
+      RSpec.slacker_reset
+
+      RSpec.configure do |config|
+        # Global "before" hooks to begin a transaction
+        config.before(:each) do
+          before_proc.call(example)
+        end
+
+        # Global "after" hooks to rollback a transaction
+        config.after(:each) do
+          after_proc.call(example)
+        end
+
+        # Slacker's RSpec extension module
+        config.include(Slacker::RSpecExt)
+        config.extend(Slacker::RSpecExt)
+
+        config.output_stream = @configuration.output_stream
+        config.error_stream = @configuration.error_stream
+
+        config.formatters << @configuration.formatter unless @configuration.formatter.nil?
+      end
+    end
+
+    # Tests the current folder's structure
+    def test_folder_structure()
+      target_folder_structure.each do |dir|
+        if !File.directory?(get_path(dir))
+          throw_error("Cannot find directory \"#{get_path(dir)}\"")
+        end
+      end
+    end
+
+    def throw_error(msg)
+      @error_message = msg
+      throw :error_exit, true
+    end
+  end
+end

data/lib/slacker/command_line_formatter.rb

@@ -0,0 +1,59 @@
+require 'slacker/formatter'
+require 'rspec/core/formatters/progress_formatter'
+
+module Slacker
+  class CommandLineFormatter < RSpec::Core::Formatters::ProgressFormatter
+    include Slacker::Formatter
+
+    def initialize(output)
+      super(output)
+      @failed_examples_count = 0
+      @passed_examples_count = 0
+    end
+
+    def example_passed(example)
+      process_example_debug_output(example, false)
+      super(example)
+    end
+
+    def example_failed(example)
+      process_example_debug_output(example, true)
+      super(example)
+    end
+
+private
+
+    def process_example_debug_output(example, example_failed)
+      if example_failed
+        @failed_examples_count += 1
+        debug_output(example, Slacker.configuration.expand_path('debug/failed_examples'), @failed_examples_count, example_failed)
+      else
+        @passed_examples_count += 1
+        debug_output(example, Slacker.configuration.expand_path('debug/passed_examples'), @passed_examples_count, example_failed)
+      end
+    end
+
+    def debug_output(example, out_folder, file_number, example_failed)
+      # Write out the SQL
+      File.open("#{out_folder}/example_#{'%03d' % file_number}.sql", 'w') do |out_file|
+        out_file.write(get_formatted_example_sql(example, example_failed))
+      end
+    end
+
+    def get_formatted_example_sql(example, example_failed)
+      sql = <<EOF
+-- Example "#{example.metadata[:full_description]}"
+-- #{example.metadata[:location]}
+-- Executed at #{example.metadata[:execution_result][:started_at]}
+
+#{example.metadata[:sql]}
+
+--               SLACKER RESULTS
+-- *******************************************
+#{example_failed ? example_failure_text(example).split("\n").collect{|line| '-- ' + line}.join("\n") : '--              Example Passed OK'}
+-- *******************************************
+EOF
+      sql.strip
+    end
+  end
+end