marjoree 0.0.1

data/lib/odbc_overrides.rb

@@ -0,0 +1,33 @@
+class ODBC::TimeStamp
+    alias_method :old_to_s, :to_s
+
+    def ==( pal )
+        return to_s.index( pal.to_s ) == 0
+    end
+
+    def to_s
+        datetime = old_to_s
+        date, time, fraction = datetime.split(" ")
+
+        fraction_text = (fraction == '0') ? '' : ".#{fraction}"
+        return "#{date} #{time}#{fraction_text}"
+    end
+
+    def self.from_date(date)
+        formatted_date = date.strftime '%Y-%m-%d %H:%M:%S.000'
+        return ODBC::TimeStamp.new(formatted_date)
+    end
+end
+
+class ODBC::Error
+    def error_code
+        start_index = to_s =~ /(\()/
+        end_index = to_s =~ /(\))/
+        end_index -= 1
+        return to_s.slice( (start_index + 1 ), (end_index - start_index ) ).to_i
+    end
+
+    def error_message
+        return to_s.split( /\]/ ).last.rstrip!
+    end
+end

data/lib/result_set_wrapper.rb

@@ -0,0 +1,193 @@
+class ResultSetWrapper
+    attr_reader :columns
+    attr_reader :hashes
+
+    def initialize( statement, output_param_names = [] )
+        @padding = " "
+        @spacer = " "
+        @columns = statement.columns
+        @hashes = []
+
+        if output_param_names.length > 0
+            apply_output_params( output_param_names, statement )
+        else
+            extract_results( statement )
+        end
+    end
+
+    def apply_output_params( output_param_names, statement )
+        for i in 0..( output_param_names.length - 1 )
+            value = statement.fetch![0]
+            statement.more_results
+
+            var_name = "#{output_param_names[i]}"
+            instance_variable_set( var_name, value )
+        end
+    end
+
+    def method_missing( name )
+        member_var = eval( "@#{name}" )
+        if !member_var.nil?
+            return member_var
+        else
+            return super.method_missing( name )
+        end
+    end
+
+    def is_output_param?( name )
+        return !eval( "#{name}" ).nil?
+    end
+
+    # Returns the number of rows in self.
+    def count
+        return @hashes.size
+    end
+
+    # Returns the number of rows in self.
+    def size
+        return count
+    end
+
+    # Returns true if self contains zero rows.
+    def empty?
+        return count == 0
+    end
+
+    # Iterates round each row applying a block.
+    def collect
+        @hashes.each do |hash|
+            yield hash
+        end
+    end
+
+    # Returns true if the contents of the 'expected_result_set' is held within self.
+    def has?( expected_result_set )
+        return contains?( expected_result_set.row_hashes )
+    end
+
+    # Returns true if the contents of the 'expected_rows' map is held within self.
+    def contains?( *expected_rows )
+        expected_rows.flatten.each do |expected|
+            return false unless contains_row?( expected )
+        end
+
+        return true
+    end
+
+    def contains_row?( expected )
+        expected_with_symbols = convert_keys_to_symbols( expected )
+        @hashes.each do |actual|
+            return true if actual == actual.merge(expected_with_symbols)
+        end
+
+        return false
+    end
+
+    # Provides the contents of self in the form of a table.
+    def to_s
+        column_widths = widest_value_in_columns
+
+        result = create_header_row( column_widths )
+        result << "\n" + create_separator_row( column_widths )
+
+        @hashes.each do |row|
+            result << "\n" + create_data_row( row, column_widths )
+        end
+
+        return result
+    end
+
+    private
+
+    def create_separator_row( column_widths )
+        result = ""
+
+        column_widths.each do |width|
+            result << " "
+            num_bars = width + ( @padding.length * 2 )
+            num_bars.times { result << "-" }
+        end
+
+        result << " "
+
+        return result
+    end
+
+    def create_header_row( column_widths )
+        result = ""
+
+        counter = 0
+        column_names.each do |header|
+            result << "|#{@padding}" + create_entry( header, column_widths[counter] ) + "#{@padding}"
+            counter += 1
+        end
+
+        return result + "|"
+    end
+
+    def create_data_row( row, column_widths )
+        result = ""
+
+        counter = 0
+        column_names.each do |header|
+            result << "|#{@padding}" + create_entry( row[header.to_sym].to_s, column_widths[counter] ) + "#{@padding}"
+            counter += 1
+        end
+
+        return result + "|"
+    end
+
+    def create_entry( header, expected_width )
+        if header.length == expected_width
+            return header
+        end
+
+        num_prefix_spaces = (expected_width - header.length)/2
+        num_postfix_spaces = expected_width - (num_prefix_spaces + header.length )
+        pre = ""
+        post = ""
+        num_prefix_spaces.times{ pre << " " }
+        num_postfix_spaces.times{ post << " " }
+
+        return pre + header + post
+    end
+
+    def widest_value_in_columns
+        result = []
+
+        column_names.each do |header|
+            largest = header.length
+            @hashes.each do |row|
+                if row[header.to_sym].to_s.length > largest
+                    largest = row[header.to_sym].length
+                end
+            end
+
+            result << largest
+            puts
+        end
+
+        return result
+    end
+
+    def column_names
+        return columns.keys
+    end
+
+    def convert_keys_to_symbols( row )
+        result = {}
+
+        row.each do |key, value|
+            result[key.to_sym] = value
+        end
+
+        return result
+    end
+
+    def extract_results( statement )
+        statement.each_hash do |row|
+            @hashes << convert_keys_to_symbols( row )
+        end
+    end
+
+end

data/rakefile.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rake'
+require 'rake/packagetask'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+task :default => ['test', "rdoc"]
+
+spec = Gem::Specification.new do |s|
+  s.name = 'marjoree'
+  s.version = "0.0.1"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Marjoree is the Stored Procedure Testing Library"
+  s.homepage = "http://www.jiggypete.com"
+  s.files = Dir["./**/*"]
+  s.has_rdoc=true  
+  s.author = "Peter Aitken, Ian Davies, Gus MacCuish"
+  s.email = "jiggypete@googlemail.com"
+end
+
+Rake::GemPackageTask.new(spec) do |p|	
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+  p.gem_file
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList['tests/all_tests.rb']
+  t.verbose = true
+end

data/tests/all_tests.rb

@@ -0,0 +1,15 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'marjoree'
+require 'expected_result_set'
+require 'rake'
+
+include Marjoree
+connect('ODBC_DATASOURCE_NAME', 'USERNAME', 'PASSWORD' )
+Kernel.at_exit { disconnect }
+
+FileList['**/test_*.rb'].to_a.each do |test_case|
+  require test_case
+end
+
+

data/tests/sprocs/test_error_sproc.sp

@@ -0,0 +1,11 @@
+CREATE PROCEDURE test_error_sproc
+(
+    @error_code int,
+    @error_message char(50)
+)
+AS
+BEGIN
+    RAISERROR @error_code @error_message
+    RETURN 1
+END
+

data/tests/sprocs/test_sproc.sp

@@ -0,0 +1,5 @@
+CREATE PROCEDURE test_sproc
+AS
+BEGIN
+    SELECT * FROM TEST_TABLE
+END

data/tests/sprocs/test_sproc_with_mixed_params.sp

@@ -0,0 +1,15 @@
+CREATE PROCEDURE test_sproc_with_mixed_params
+(
+    @input_text varchar(20),
+	@output_number int     output,
+	@input_first_number int,
+	@output_text   varchar(10) output,
+	@input_second_number int
+)
+AS
+BEGIN
+    select @output_number = 15
+
+    select @output_text = 'results'
+END
+

data/tests/sprocs/test_sproc_with_output_params.sp

@@ -0,0 +1,10 @@
+CREATE PROCEDURE test_sproc_with_output_params
+(
+	@output_number int     output,
+	@output_text   varchar(10) output
+)
+AS
+BEGIN
+    select @output_number = 15
+    select @output_text = 'results'
+END

data/tests/sprocs/test_sproc_with_params.sp

@@ -0,0 +1,9 @@
+CREATE PROCEDURE test_sproc_with_params
+(
+	@id int,
+	@value int
+)
+AS
+BEGIN
+    SELECT * FROM TEST_TABLE WHERE @id = id AND @value = value
+END

data/tests/sprocs/test_sproc_with_select_and_ops.sp

@@ -0,0 +1,12 @@
+CREATE PROCEDURE test_sproc_with_select_and_ops
+(
+	@output_number int     output,
+	@output_text   varchar(10) output
+)
+AS
+BEGIN
+    select @output_number = 15
+    select @output_text = 'results'
+
+    select * from TEST_TABLE
+END

data/tests/test_contains.rb

@@ -0,0 +1,27 @@
+require 'test/unit'
+
+class TestContainsMethodOnMarjoree < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+        $db.do( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NOT NULL )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 0, 10 )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 1, 11 )" )
+    end
+
+    def test_contains
+        assert( contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+        assert( contains?( "TEST_TABLE", :id => 1, :value => 11 ) )
+        assert( contains?( "TEST_TABLE", :id => 1 ) )
+        assert( !contains?( "TEST_TABLE", :id => 2, :value => 12 ) )
+    end
+
+    def test_contains?_with_bad_column_names
+        assert( !contains?( "TEST_TABLE", :wibble => 'wobble' ) )
+    end
+
+    def teardown
+        $db.do( "TRUNCATE TABLE TEST_TABLE" )
+        $db.do( "DROP TABLE TEST_TABLE" )
+    end
+end

data/tests/test_delete.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+
+class TestDeleteOnMarjoree < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+        $db.do( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NOT NULL )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 0, 10 )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 1, 11 )" )
+    end
+
+    def test_delete
+        assert( contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+
+        delete( "TEST_TABLE", :id => 0 )
+        assert( !contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+    end
+
+    def test_delete_where_table_does_not_exist
+        begin
+            delete( "DUFF_TABLE", :id => 0 )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_delete_where_column_header_does_not_exist
+        begin
+            delete( "TEST_TABLE", :mince => 0 )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_delete_where_column_value_is_incorrect_type
+        begin
+            delete( "TEST_TABLE", :id => 'bad type' )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def teardown
+        $db.do( "TRUNCATE TABLE TEST_TABLE" )
+        $db.do( "DROP TABLE TEST_TABLE" )
+    end
+end

data/tests/test_expected_result_set.rb

@@ -0,0 +1,40 @@
+require 'test/unit'
+
+class TestExpectedResultSet < Test::Unit::TestCase
+
+    def setup
+        @testee = ExpectedResultSet.new
+    end
+
+    def test_row_hashes_with_one_entry
+        @testee.columns = ["firstColumn"]
+        @testee.rows << [2]
+
+        assert_equal( [{"firstColumn"=>2}], @testee.row_hashes )
+    end
+
+    def test_columns_are_strings
+        @testee.columns = ["firstColumn"]
+        assert_equal ['firstColumn'], @testee.columns
+    end
+
+    def test_row_hash_with_one_row_and_one_column
+        @testee.columns = ["firstColumn"]
+        @testee.rows << [2]
+        assert_equal( {"firstColumn"=>2}, @testee.row_hash( 0 ) )
+    end
+
+    def test_row_hash_with_one_rows_and_two_columns
+        @testee.columns = ["firstColumn", "secondColumn"]
+        @testee.rows << [123, 456]
+        assert_equal( {"firstColumn"=>123, "secondColumn"=>456}, @testee.row_hash( 0 ) )
+    end
+
+    def test_row_hash_with_two_rows_and_two_columns
+        @testee.columns = ["firstColumn", "secondColumn"]
+        @testee.rows << [123, 234]
+        @testee.rows << [345, 567]
+        assert_equal( {"firstColumn"=>123, "secondColumn"=>234}, @testee.row_hash( 0 ) )
+        assert_equal( {"firstColumn"=>345, "secondColumn"=>567}, @testee.row_hash( 1 ) )
+    end
+end

data/tests/test_insert.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+
+class TestInsertOnMarjoree < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+        $db.do( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NOT NULL )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 0, 10 )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 1, 11 )" )
+    end
+
+    def test_insert
+        assert( !contains?( "TEST_TABLE", :id => 2 ) )
+
+        insert( "TEST_TABLE", :id => 2, :value => 12 )
+        assert( contains?( "TEST_TABLE", :id => 2, :value => 12 ) )
+    end
+
+    def test_insert_with_bad_table
+        begin
+            insert( "TABLE_NOT_INT_DB", :id => 2, :value => 12 )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_insert_with_bad_column_names
+        begin
+            insert( "TEST_TABLE", :fred => 2, :wilma => 12 )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_insert_with_values_of_incorrect_type
+        begin
+            insert( "TEST_TABLE", :id => 'text', :value => 12 )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def teardown
+        $db.do( "TRUNCATE TABLE TEST_TABLE" )
+        $db.do( "DROP TABLE TEST_TABLE" )
+    end
+end

data/tests/test_marjoree.rb

@@ -0,0 +1,91 @@
+require 'test/unit'
+require 'result_set_wrapper'
+
+class TestMarjoree < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+        $db.do( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NOT NULL )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 0, 10 )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 1, 11 )" )
+    end
+
+    def test_select
+        result_set = select( "TEST_TABLE" )
+
+        assert_equal( 2, result_set.count )
+    end
+
+    def test_select_with_bad_table
+        begin
+            resultSet = select( "TABLE_NOT_INT_DB" )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_num_rows_for_table
+        assert_equal( 2, num_rows( "TEST_TABLE" ) )
+    end
+
+    def test_num_rows_with_bad_table
+        begin
+            num_rows( "TABLE_NOT_INT_DB" )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_contains?
+        assert( contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+        assert( contains?( "TEST_TABLE", :id => 1, :value => 11 ) )
+        assert( contains?( "TEST_TABLE", :id => 1 ) )
+        assert( !contains?( "TEST_TABLE", :id => 2, :value => 12 ) )
+    end
+
+    def test_contains?_with_bad_column_names
+        assert( !contains?( "TEST_TABLE", :wibble => 'wobble' ) )
+    end
+
+    def test_insert
+        assert( !contains?( "TEST_TABLE", :id => 2 ) )
+
+        insert( "TEST_TABLE", :id => 2, :value => 12 )
+        assert( contains?( "TEST_TABLE", :id => 2, :value => 12 ) )
+    end
+
+    def test_insert_with_bad_table
+        begin
+            insert( "TABLE_NOT_INT_DB", :id => 2, :value => 12 )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def test_delete
+        assert( contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+
+        delete( "TEST_TABLE", :id => 0 )
+        assert( !contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+    end
+
+    def test_truncate
+        assert( num_rows( "TEST_TABLE" ) > 0 )
+
+        truncate( "TEST_TABLE" )
+        assert_equal( 0, num_rows( "TEST_TABLE" ) )
+    end
+
+    def test_update
+        assert( contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+
+        update( "TEST_TABLE", { :id => 0 }, :value => 20 )
+        assert( !contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
+        assert( contains?( "TEST_TABLE", :id => 0, :value => 20 ) )
+    end
+
+    def teardown
+        $db.do( "TRUNCATE TABLE TEST_TABLE" )
+        $db.do( "DROP TABLE TEST_TABLE" )
+    end
+end

data/tests/test_num_rows.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+
+class TestNumRowsOnMarjoree < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+        $db.do( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NOT NULL )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 0, 10 )" )
+        $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 1, 11 )" )
+    end
+
+    def test_num_rows_for_table
+        assert_equal( 2, num_rows( "TEST_TABLE" ) )
+    end
+
+    def test_num_rows_for_table_using_where
+        assert_equal( 1, num_rows( "TEST_TABLE", {:id=>1} ) )
+    end
+
+    def test_num_rows_with_bad_table
+        begin
+            num_rows( "TABLE_NOT_INT_DB" )
+            fail
+        rescue ODBC::Error
+        end
+    end
+
+    def teardown
+        $db.do( "TRUNCATE TABLE TEST_TABLE" )
+        $db.do( "DROP TABLE TEST_TABLE" )
+    end
+end