marjoree 0.0.1 → 0.0.9

data/tests/marjoree/test_connection_details.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'marjoree'
+require 'marjoree/fixtures'
+require 'marjoree/odbc_connection_wrapper'
+
+#Test::Unit::TestCase.fixture_path = File.join(File.dirname(__FILE__), '../fixtures')
+#Test::Unit::TestCase.odbc_config_path = File.join(File.dirname(__FILE__), '../odbc_config')
+
+class TestConnectionDetails < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+        @original_odbc_config_path = OdbcConnectionWrapper.odbc_config_path
+        OdbcConnectionWrapper.odbc_config_path = './tests/multiple_odbc_config/connections.yml'
+    end
+
+    def test_connection_details
+        path = OdbcConnectionWrapper.odbc_config_path
+        puts path
+
+        yaml = IO.read(path)
+        yaml_contents = YAML.load(ERB.new(yaml).result(binding))
+
+        assert_equal( 4, yaml_contents.size )
+
+        assert_contains_username_and_password( yaml_contents['first_db'] )
+        assert_contains_username_and_password( yaml_contents['second_db'] )
+
+        default_db_map = yaml_contents['default']
+        assert( 'first_db', default_db_map['obdc_connection'] )
+    end
+
+    def teardown
+        OdbcConnectionWrapper.odbc_config_path = @original_odbc_config_path
+    end
+
+    private
+
+    def assert_contains_username_and_password( details_map )
+        assert( details_map.keys.include?( 'username' ) )
+        assert( details_map.keys.include?( 'password' ) )
+    end
+
+end

data/tests/marjoree/test_drop_user_objects.rb

@@ -0,0 +1,52 @@
+require 'test/unit'
+
+class TestDropUserObjects < Test::Unit::TestCase
+    include Marjoree
+
+    def setup
+
+        $db.do( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NOT NULL )" )
+        $db.do( "CREATE VIEW VW_TEST_TABLE AS SELECT * FROM TEST_TABLE" )
+        load_sproc 'test_sproc.sp'
+    end
+
+    def test_drop_user_tables
+         drop_user_tables
+         assert_equal 0, count( :sysobjects, {:type => 'U'} )
+     end
+
+    def test_drop_user_tables
+         drop_user_views
+         assert_equal 0, count( :sysobjects, {:type => 'V'} )
+    end
+
+    def test_drop_user_sprocs
+         drop_user_sprocs
+         assert_equal 0, count( :sysobjects, {:type => 'P'} )
+    end
+
+    def teardown
+        begin
+            $db.do( "DROP PROCEDURE test_sproc" )
+        rescue
+        end
+
+        begin
+            $db.do( "DROP VIEW VW_TEST_TABLE" )
+        rescue
+        end
+
+        begin
+            $db.do( "DROP TABLE TEST_TABLE" )
+        rescue
+        end
+    end
+
+    private
+
+    def load_sproc( sproc_name )
+        dir = File.dirname(__FILE__)
+        sproc_contents = IO.readlines( "#{dir}/../sprocs/#{sproc_name}" ).join
+        $db.do sproc_contents
+    end
+end

data/tests/marjoree/test_expected_result_set.rb

@@ -0,0 +1,111 @@
+$:.unshift File.dirname(__FILE__) + "/../../lib"
+
+require 'test/unit'
+require 'expected_result_set'
+
+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
+
+	def test_adding_row_as_hash
+		@testee.with_row :first=>1, :second=>2
+		assert_equal({"first" => 1, "second"=>2}, @testee.row_hash(0))
+	end
+
+	def test_adding_multiple_rows_as_hash
+		@testee.with_row(:first=>1, :second=>2).with_row(:first=>10, :second=>20)
+		assert_equal({"first" => 1, "second"=>2}, @testee.row_hash(0))
+		assert_equal({"first" => 10, "second"=>20}, @testee.row_hash(1))
+	end
+
+	def test_adding_a_key_to_a_row_adds_that_to_previously_added_rows_with_nil_value
+		@testee.with_row :first=>1
+		@testee.with_row :first=>10, :second=>20
+		assert_equal({"first" => 1, "second"=>nil}, @testee.row_hash(0))
+		assert_equal({"first" => 10, "second"=>20}, @testee.row_hash(1))
+    end
+
+    def test_adding_a_fixture
+        fixture_map = { "firstColumn" => "first", "secondColumn" => "last" }
+
+        @testee.columns = [ "firstColumn", "secondColumn"]
+        assert( @testee.rows.empty? )
+
+        @testee.add_fixture( fixture_map )
+        assert( !@testee.rows.empty? )
+
+        assert_equal( [ "first", "last" ], @testee.rows[0] )
+    end
+
+    def test_adding_a_fixture_which_has_more_columns_than_expected_is_interested_in
+        fixture_map = { "firstColumn" => "first", "secondColumn" => "last", "not very interesting column" => "value" }
+
+        @testee.columns = [ "firstColumn", "secondColumn"]
+        @testee.add_fixture( fixture_map )
+
+        assert_equal( [ "first", "last" ], @testee.rows[0] )
+    end
+
+    def test_adding_a_fixture_which_has_less_columns_than_expected
+        fixture_map = { "firstColumn" => "first" }
+
+        @testee.columns = [ "firstColumn", "secondColumn"]
+        @testee.add_fixture( fixture_map )
+
+        assert_equal( [ "first", nil ], @testee.rows[0] )
+    end
+
+    def test_adding_two_fixtures_with_two_calls
+        @testee.columns = [ :one, :two ]
+        @testee.add_fixture( {:one => "first fixture first value", :two => "first fixture second value"} )
+        @testee.add_fixture( {:one => "second fixture first value", :two => "second fixture second value"} )
+
+        assert_equal( [ "first fixture first value", "first fixture second value" ], @testee.rows[0] )
+        assert_equal( [ "second fixture first value", "second fixture second value" ], @testee.rows[1] )
+    end
+
+    def test_adding_two_fixtures_that_join
+        @testee.columns = [ :parent_name, :child_name ]
+        parent_fixture_map = {:parent_name => "I am the parent table record", :id_join => 5 }
+        child_fixture_map = {:child_name => "I am the child table record", :id_join => 5 }
+        @testee.add_fixture parent_fixture_map, child_fixture_map
+
+        assert_equal( 1, @testee.rows.length )
+        assert_equal( [ "I am the parent table record", "I am the child table record" ], @testee.rows[0] )        
+    end
+
+end

data/tests/marjoree/test_fixtures.rb

@@ -0,0 +1,112 @@
+require 'test/unit'
+require 'marjoree'
+require 'marjoree/fixtures'
+require 'expected_result_set'
+
+Test::Unit::TestCase.fixture_path = File.join(File.dirname(__FILE__), '../fixtures')
+
+include Marjoree
+
+class TestFixtureSql < Test::Unit::TestCase
+
+    def self.stub_fixtures(*tables)
+        execute( "CREATE TABLE A( id INT, name VARCHAR(255) )" ) if( !get_user_tables.include?( 'A' ) )
+        execute( "CREATE TABLE B( id_b INT )" ) if( !get_user_tables.include?( 'B' ) )
+        fixtures(*tables)
+    end
+
+    stub_fixtures :A, :B
+
+    # tests are numbered to ensure the running order
+
+    def test_1    # That A and B are inserted into the db from yml files
+        assert_A_initialisation
+
+        #from yml file
+        assert_equal( 1, A(:one).id )
+        assert_equal( 'Marvin', A(:one).name )
+
+        assert_B_initialisation
+
+        #from yml file
+        assert_equal( 1, B(:one).id_b)
+        assert_equal( 2, B(:two).id_b)
+    end
+
+    def test_2 # this test will update the fixture data
+        update "B", {:id_b => 2}, {:id_b => 100}
+        delete "B", {:id_b => 1}
+
+        expected = ExpectedResultSet.new( :id_b )
+        expected.rows << [100]
+
+        assert_results( expected, select( "B" ) )
+        assert_equal( 1, select( "B" ).size )
+    end
+
+    def test_3   # the fixtures code should have completely truncated table A & B and reinitialised them from the yml.
+        assert_A_initialisation
+        assert_B_initialisation
+    end
+
+    private
+
+    def assert_A_initialisation
+        actual_a = select "A"
+        assert_equal( 1, actual_a.size )
+
+        assert_equal( 1, actual_a.hashes[0][:id] )
+        assert_equal( 'Marvin', actual_a.hashes[0][:name] )
+    end
+
+    def assert_B_initialisation
+        actual_b = select "B"
+        assert_equal( 2, actual_b.size )
+
+        expected = ExpectedResultSet.new( :id_b )
+        expected.rows << [1]
+        expected.rows << [2]
+        assert_results( expected, actual_b )
+    end
+end
+
+class TestFixtures < Test::Unit::TestCase
+  fixtures :A, :B
+
+  def test_hash_to_sql
+    testee = { :key1 => 'value1', :key2 => 3.14, :key3 => 12 }
+    table_name = :ABC
+
+    sql = testee.to_sql(table_name)
+    assert sql =~ /^INSERT INTO ABC\((.*)\) VALUES\((.*)\)$/
+    keys = $1
+    values = $2
+
+    assert_equal "key1,key2,key3", keys.split(/,/).sort.join(',')
+    assert_equal "'value1',12,3.14", values.split(/,/).sort.join(',')
+  end
+
+  def test_retrieving_yaml_defined_value
+    a = A(:one)
+    b1 = B(:one)
+    b2 = B(:two)
+
+    assert_equal({ 'id' => 1, 'name' => 'Marvin' }, a)
+    assert_equal({ 'id_b' => 1 }, b1)
+    assert_equal({ 'id_b' => 2 }, b2)
+
+    assert_equal 1, a.id
+    assert_equal 'Marvin', a.name
+
+    assert_equal 1, b1.id
+    assert_equal 2, b2.id
+  end
+
+  def test_retrieving_value_not_defined_in_yaml_is_nil
+    assert_equal nil, A(:one).superhero_name
+  end
+
+  def test_defining_a_default_on_map
+    assert_equal "Captain Marvel", A(:one).with_defaults(:superhero_name=>"Captain Marvel").superhero_name
+  end
+end

data/tests/{test_marjoree.rb → marjoree/test_marjoree.rb}

@@ -1,11 +1,13 @@
+$:.unshift File.dirname(__FILE__) + "/../../lib"
+
 require 'test/unit'
-require 'result_set_wrapper'
+require 'marjoree'
 
 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( "CREATE TABLE TEST_TABLE( id    int     NOT NULL,    value int NULL )" )
         $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 0, 10 )" )
         $db.do( "INSERT INTO TEST_TABLE ( id, value ) VALUES( 1, 11 )" )
     end
@@ -36,6 +38,16 @@ class TestMarjoree < Test::Unit::TestCase
         end
     end
 
+    def test_display_value_for
+        update( "TEST_TABLE", { :id => 0 }, :value => nil )
+        sql = "SELECT value FROM TEST_TABLE WHERE id = 0"
+        result = []
+        execute( sql ).collect do |hash|
+                result << hash[:value]
+            end
+        assert_equal( 'NULL', display_value_for(result[0]))
+    end
+
     def test_contains?
         assert( contains?( "TEST_TABLE", :id => 0, :value => 10 ) )
         assert( contains?( "TEST_TABLE", :id => 1, :value => 11 ) )

data/tests/marjoree/test_multiple_db_fixtures.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'marjoree'
+require 'marjoree/fixtures'
+require 'expected_result_set'
+
+Test::Unit::TestCase.fixture_path = File.join(File.dirname(__FILE__), '../fixtures')
+
+class TestMultipleDBFixtures < Test::Unit::TestCase
+    include Marjoree
+
+    # `odbcconf /A {configdsn "SYBASE ASE ODBC Driver" "DSN=first_db|NA=LGLAIB9Y2Y33J,5000|Uid=sa|Pwd=|Database=CRDMGR"}`
+    # `odbcconf /A {configdsn "SYBASE ASE ODBC Driver" "DSN=second_db|NA=LGLAIB9Y2Y33J,5000|Uid=sa|Pwd=|Database=CRDMGR_TEST"}`
+
+    def self.stub_fixtures(*tables)
+        connect_me_to 'first_db'
+        execute( "CREATE TABLE FIRST( id INT, name VARCHAR(255) )" ) if( !get_user_tables.include?( 'FIRST' ) )
+
+        connect_me_to 'second_db'
+        execute( "CREATE TABLE SECOND( id INT )" ) if( !get_user_tables.include?( 'SECOND' ) )
+
+        connect_me_to 'first_db'
+        fixtures(*tables)
+    end
+
+    stub_fixtures :FIRST, :SECOND
+
+    def test_fixtures_inserted_into_correct_db
+        connect_me_to 'first_db'
+        assert_equal( 2, count( "FIRST" ) )
+
+        connect_me_to 'second_db'
+        assert_equal( 3, count( "SECOND" ) )
+    end
+    
+end

data/tests/marjoree/test_odbc_connection_wrapper.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+
+class TestMultipleOdbcConnectionWrapper < Test::Unit::TestCase
+
+    def setup
+        @original_odbc_config_path = OdbcConnectionWrapper.odbc_config_path
+        OdbcConnectionWrapper.odbc_config_path = './tests/multiple_odbc_config/connections.yml'
+        @testee = OdbcConnectionWrapper.new
+    end
+
+    def test_single_db_connections_is_also_used_as_default
+        @testee.connect_me_to( "first_db" )
+        @testee.execute( "CREATE TABLE WRAPPER_TEST_TABLE( id INT )")
+        assert( table_in_db?( "WRAPPER_TEST_TABLE" ) )
+
+        @testee.connect_me_to( "second_db" )
+        assert( !table_in_db?( "WRAPPER_TEST_TABLE" ) )
+
+        @testee.connect_me_to( "default" )
+        assert( table_in_db?( "WRAPPER_TEST_TABLE" ) )
+    end
+
+    def teardown
+        @testee.connect_me_to( "first_db" )
+        @testee.execute( "DROP TABLE WRAPPER_TEST_TABLE" ) if ( table_in_db?( "WRAPPER_TEST_TABLE" ) )
+        @testee.disconnect_me
+
+        OdbcConnectionWrapper.odbc_config_path = @original_odbc_config_path
+
+    end
+
+    def test_connections_are_lazily_loaded
+       assert_raise(ODBC::Error) {@testee.connect_me_to("i_do_not_exist")}
+    end
+
+    
+    private
+
+    def table_in_db?( table_name )
+        result_set =  @testee.execute( "SELECT * FROM sysobjects WHERE type = 'U'" )
+        object_names = []
+        result_set.hashes.each do |row|
+            object_names << row[:name]
+        end
+        return object_names.include?( table_name )
+    end
+end