tiny_tds 0.4.3 → 0.4.4

data/test/schema_test.rb

@@ -0,0 +1,284 @@
+# encoding: utf-8
+require 'test_helper'
+
+class SchemaTest < TinyTds::TestCase
+  
+  context 'Casting SQL Server schema' do
+  
+    setup do
+      @@current_schema_loaded ||= load_current_schema
+      @client ||= new_connection
+      @gif1px = ruby19? ? File.read('test/schema/1px.gif',:mode=>"rb:BINARY") : File.read('test/schema/1px.gif')
+    end
+  
+    context 'for shared types' do
+      
+      should 'cast bigint' do
+        assert_equal -9223372036854775807, find_value(11, :bigint)
+        assert_equal 9223372036854775806, find_value(12, :bigint)
+      end
+      
+      should 'cast binary' do
+        binary_value = sqlserver_azure? ? @gif1px : @gif1px+"\000"
+        value = find_value(21, :binary_50)
+        assert_equal binary_value, value
+        assert_binary_encoding(value)
+      end
+      
+      should 'cast bit' do
+        assert_equal true, find_value(31, :bit)
+        assert_equal false, find_value(32, :bit)
+        assert_equal nil, find_value(21, :bit)
+      end
+      
+      should 'cast char' do
+        partial_char = sqlserver_azure? ? '12345678' : '12345678  '
+        assert_equal '1234567890', find_value(41, :char_10)
+        assert_equal partial_char, find_value(42, :char_10)
+        assert_utf8_encoding find_value(42, :char_10)
+      end
+      
+      should 'cast datetime' do
+        # 1753-01-01T00:00:00.000
+        v = find_value 61, :datetime
+        assert_instance_of DateTime, v, 'not in range of Time class'
+        assert_equal 1753, v.year
+        assert_equal 01, v.month
+        assert_equal 01, v.day
+        assert_equal 0, v.hour
+        assert_equal 0, v.min
+        assert_equal 0, v.sec
+        assert_equal 0, v.usec
+        # 9999-12-31T23:59:59.997
+        v = find_value 62, :datetime
+        assert_instance_of DateTime, v, 'not in range of Time class'
+        assert_equal 9999, v.year
+        assert_equal 12, v.month
+        assert_equal 31, v.day
+        assert_equal 23, v.hour
+        assert_equal 59, v.min
+        assert_equal 59, v.sec
+        assert_equal 997000, v.usec unless ruby186?
+        assert_equal local_offset, find_value(61, :datetime, :timezone => :local).offset
+        assert_equal 0, find_value(61, :datetime, :timezone => :utc).offset
+        # 2010-01-01T12:34:56.123
+        v = find_value 63, :datetime
+        assert_instance_of Time, v, 'in range of Time class'
+        assert_equal 2010, v.year
+        assert_equal 01, v.month
+        assert_equal 01, v.day
+        assert_equal 12, v.hour
+        assert_equal 34, v.min
+        assert_equal 56, v.sec
+        assert_equal 123000, v.usec
+        assert_equal utc_offset, find_value(63, :datetime, :timezone => :local).utc_offset
+        assert_equal 0, find_value(63, :datetime, :timezone => :utc).utc_offset
+      end
+      
+      should 'cast decimal' do
+        assert_instance_of BigDecimal, find_value(91, :decimal_9_2)
+        assert_equal BigDecimal.new('12345.01'), find_value(91, :decimal_9_2)
+        assert_equal BigDecimal.new('1234567.89'), find_value(92, :decimal_9_2)
+        assert_equal BigDecimal.new('0.0'), find_value(93, :decimal_16_4)
+        assert_equal BigDecimal.new('123456789012.3456'), find_value(94, :decimal_16_4)
+      end
+      
+      should 'cast float' do
+        assert_equal 123.00000001, find_value(101,:float)
+        assert_equal 0.0, find_value(102,:float)
+        assert_equal find_value(102,:float).object_id, find_value(102,:float).object_id, 'use global zero float'
+        assert_equal 123.45, find_value(103,:float)
+      end
+      
+      should 'cast image' do
+        value = find_value(141,:image)
+        assert_equal @gif1px, value
+        assert_binary_encoding(value)
+      end
+      
+      should 'cast int' do
+        assert_equal -2147483647, find_value(151, :int)
+        assert_equal 2147483646, find_value(152, :int)
+      end
+      
+      should 'cast money' do
+        assert_instance_of BigDecimal, find_value(161, :money)
+        assert_equal BigDecimal.new('4.20'), find_value(161, :money)
+        assert_equal BigDecimal.new('922337203685477.5806'), find_value(163 ,:money)
+        assert_equal BigDecimal.new('-922337203685477.5807'), find_value(162 ,:money)
+      end
+      
+      should 'cast nchar' do
+        assert_equal '1234567890', find_value(171, :nchar_10)
+        assert_equal '123456åå  ', find_value(172, :nchar_10)
+        assert_equal 'abc123    ', find_value(173, :nchar_10)
+      end
+      
+      should 'cast ntext' do
+        assert_equal 'test ntext', find_value(181, :ntext)
+        assert_equal 'test ntext åå', find_value(182, :ntext)
+        assert_utf8_encoding find_value(182, :ntext)
+        # If this test fails, try setting the "text size" in your freetds.conf. See: http://www.freetds.org/faq.html#textdata
+        large_value = "x" * 5000
+        large_value_id = @client.execute("INSERT INTO [datatypes] ([ntext]) VALUES (N'#{large_value}')").insert
+        assert_equal large_value, find_value(large_value_id, :ntext)
+      end
+      
+      should 'cast numeric' do
+        assert_instance_of BigDecimal, find_value(191, :numeric_18_0)
+        assert_equal BigDecimal('191'), find_value(191, :numeric_18_0)
+        assert_equal BigDecimal('123456789012345678'), find_value(192, :numeric_18_0)
+        assert_equal BigDecimal('12345678901234567890.01'), find_value(193, :numeric_36_2)
+        assert_equal BigDecimal('123.46'), find_value(194, :numeric_36_2)
+      end
+      
+      should 'cast nvarchar' do
+        assert_equal 'test nvarchar_50', find_value(201, :nvarchar_50)
+        assert_equal 'test nvarchar_50 åå', find_value(202, :nvarchar_50)
+        assert_utf8_encoding find_value(202, :nvarchar_50)
+      end
+      
+      should 'cast real' do
+        assert_in_delta 123.45, find_value(221, :real), 0.01
+        assert_equal 0.0, find_value(222, :real)
+        assert_equal find_value(222, :real).object_id, find_value(222, :real).object_id, 'use global zero float'
+        assert_in_delta 0.00001, find_value(223, :real), 0.000001
+      end
+      
+      should 'cast smalldatetime' do
+        # 1901-01-01 15:45:00
+        v = find_value 231, :smalldatetime
+        assert_instance_of DateTime, v
+        assert_equal 1901, v.year
+        assert_equal 01, v.month
+        assert_equal 01, v.day
+        assert_equal 15, v.hour
+        assert_equal 45, v.min
+        assert_equal 00, v.sec
+        assert_equal local_offset, find_value(231, :smalldatetime, :timezone => :local).offset
+        assert_equal 0, find_value(231, :smalldatetime, :timezone => :utc).offset
+        # 2078-06-05 04:20:00
+        v = find_value 232, :smalldatetime
+        assert_instance_of DateTime, v
+        assert_equal 2078, v.year
+        assert_equal 06, v.month
+        assert_equal 05, v.day
+        assert_equal 04, v.hour
+        assert_equal 20, v.min
+        assert_equal 00, v.sec
+        assert_equal local_offset, find_value(232, :smalldatetime, :timezone => :local).offset
+        assert_equal 0, find_value(232, :smalldatetime, :timezone => :utc).offset
+      end
+      
+      should 'cast smallint' do
+        assert_equal -32767, find_value(241, :smallint)
+        assert_equal 32766, find_value(242, :smallint)
+      end
+      
+      should 'cast smallmoney' do
+        assert_instance_of BigDecimal, find_value(251, :smallmoney)
+        assert_equal BigDecimal.new("4.20"), find_value(251, :smallmoney)
+        assert_equal BigDecimal.new("-214748.3647"), find_value(252, :smallmoney)
+        assert_equal BigDecimal.new("214748.3646"), find_value(253, :smallmoney)
+      end
+      
+      should 'cast text' do
+        assert_equal 'test text', find_value(271, :text)
+        assert_utf8_encoding find_value(271, :text)
+      end
+      
+      should 'cast tinyint' do
+        assert_equal 0, find_value(301, :tinyint)
+        assert_equal 255, find_value(302, :tinyint)
+      end
+      
+      should 'cast uniqueidentifier' do
+        assert_match %r|\w{8}-\w{4}-\w{4}-\w{4}-\w{12}|, find_value(311, :uniqueidentifier)
+        assert_utf8_encoding find_value(311, :uniqueidentifier)
+      end
+      
+      should 'cast varbinary' do
+        value = find_value(321, :varbinary_50)
+        assert_equal @gif1px, value
+        assert_binary_encoding(value)
+      end
+      
+      should 'cast varchar' do
+        assert_equal 'test varchar_50', find_value(341, :varchar_50)
+        assert_utf8_encoding find_value(341, :varchar_50)
+      end
+      
+    end
+    
+    
+    context 'for 2005 and up' do
+      
+      should 'cast nvarchar(max)' do
+        assert_equal 'test nvarchar_max', find_value(211, :nvarchar_max)
+        assert_equal 'test nvarchar_max åå', find_value(212, :nvarchar_max)
+        assert_utf8_encoding find_value(212, :nvarchar_max)
+      end
+      
+      should 'cast varbinary(max)' do
+        value = find_value(331, :varbinary_max)
+        assert_equal @gif1px, value
+        assert_binary_encoding(value)
+      end
+      
+      should 'cast varchar(max)' do
+        value = find_value(351, :varchar_max)
+        assert_equal 'test varchar_max', value
+        assert_utf8_encoding(value)
+      end
+      
+      should 'cast xml' do
+        value = find_value(361, :xml)
+        assert_equal '<foo><bar>batz</bar></foo>', value
+        assert_utf8_encoding(value)
+      end
+      
+    end if sqlserver_2005? || sqlserver_2008? || sqlserver_azure?
+    
+    
+    context 'for 2008 and up' do
+      
+      should 'cast date' do
+        
+      end
+      
+      should 'cast datetime2' do
+        
+      end
+      
+      should 'cast datetimeoffset' do
+        
+      end
+      
+      should 'cast geography' do
+        
+      end
+      
+      should 'cast geometry' do
+        
+      end
+      
+      should 'cast hierarchyid' do
+        
+      end
+      
+      should 'cast time' do
+        
+      end
+      
+    end if sqlserver_2008? || sqlserver_azure?
+  
+  end
+  
+  
+  
+end
+
+
+
+
+

data/test/test_helper.rb

@@ -0,0 +1,199 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+require 'tiny_tds'
+require 'mini_shoulda'
+require 'minitest/autorun'
+
+class DateTime
+  def usec
+    if RUBY_VERSION >= '1.9'
+      (sec_fraction * 1_000_000).to_i
+    else
+      (sec_fraction * 60 * 60 * 24 * (10**6)).to_i
+    end
+  end
+end
+
+TINYTDS_SCHEMAS = ['sqlserver_2000', 'sqlserver_2005', 'sqlserver_2008', 'sqlserver_azure'].freeze
+
+module TinyTds
+  class TestCase < MiniTest::Spec
+    
+    class << self
+      
+      def current_schema
+        ENV['TINYTDS_SCHEMA'] || 'sqlserver_2008'
+      end
+      
+      TINYTDS_SCHEMAS.each do |schema|
+        define_method "#{schema}?" do
+          schema == self.current_schema
+        end
+      end
+      
+    end
+    
+    setup do
+      
+    end
+    
+    teardown do
+      ENV['TDSPORT'] = nil
+      ENV['TDSHOST'] = nil
+    end
+    
+    
+    protected
+    
+    TINYTDS_SCHEMAS.each do |schema|
+      define_method "#{schema}?" do
+        schema == self.class.current_schema
+      end
+    end
+    
+    def current_schema
+      self.class.current_schema
+    end
+    
+    def new_connection(options={})
+      client = TinyTds::Client.new(connection_options(options))
+      unless sqlserver_azure?
+        client.execute("SET ANSI_DEFAULTS ON").do
+        client.execute("SET IMPLICIT_TRANSACTIONS OFF").do
+        client.execute("SET CURSOR_CLOSE_ON_COMMIT OFF").do
+      end
+      client
+    end
+    
+    def connection_options(options={})
+      username = sqlserver_azure? ? ENV['TINYTDS_UNIT_AZURE_USER'] : 'tinytds'
+      password = sqlserver_azure? ? ENV['TINYTDS_UNIT_AZURE_PASS'] : ''
+      { :dataserver    => ENV['TINYTDS_UNIT_DATASERVER'],
+        :host          => ENV['TINYTDS_UNIT_HOST'],
+        :username      => username,
+        :password      => password,
+        :database      => 'tinytdstest',
+        :appname       => 'TinyTds Dev',
+        :login_timeout => 5,
+        :timeout       => 5,
+        :azure         => sqlserver_azure?
+      }.merge(options)
+    end
+    
+    def assert_client_works(client)
+      client.execute("SELECT 'client_works' as [client_works]").each
+    end
+    
+    def assert_new_connections_work
+      client = new_connection
+      client.execute("SELECT 'new_connections_work' as [new_connections_work]").each
+    end
+    
+    def assert_raise_tinytds_error(action)
+      error_raised = false
+      begin
+        action.call
+      rescue TinyTds::Error => e
+        error_raised = true
+      end
+      assert error_raised, 'expected a TinyTds::Error but none happened'
+      yield e
+    end
+    
+    def inspect_tinytds_exception
+      begin
+        yield
+      rescue TinyTds::Error => e
+        props = { :source => e.source, :message => e.message, :severity => e.severity, 
+                  :db_error_number => e.db_error_number, :os_error_number => e.os_error_number }
+        raise "TinyTds::Error - #{props.inspect}"
+      end
+    end
+    
+    def assert_binary_encoding(value)
+      assert_equal Encoding.find('BINARY'), value.encoding if ruby19?
+    end
+    
+    def assert_utf8_encoding(value)
+      assert_equal Encoding.find('UTF-8'), value.encoding if ruby19?
+    end
+    
+    def ruby18?
+      RUBY_VERSION < '1.9'
+    end
+    
+    def ruby186?
+      RUBY_VERSION == '1.8.6'
+    end
+    
+    def ruby19?
+      RUBY_VERSION >= '1.9'
+    end
+    
+    def ruby192?
+      RUBY_VERSION == '1.9.2'
+    end
+    
+    def rubyRbx?
+      RUBY_DESCRIPTION =~ /rubinius/i
+    end
+    
+    def load_current_schema
+      loader = new_connection
+      schema_file = File.expand_path File.join(File.dirname(__FILE__), 'schema', "#{current_schema}.sql")
+      schema_sql = ruby18? ? File.read(schema_file) : File.open(schema_file,"rb:UTF-8") { |f|f.read }
+      loader.execute(drop_sql).each
+      loader.execute(schema_sql).cancel
+      loader.execute(sp_sql).cancel
+      loader.close
+      true
+    end
+
+    def drop_sql
+      %|IF EXISTS (
+          SELECT TABLE_NAME
+          FROM INFORMATION_SCHEMA.TABLES 
+          WHERE TABLE_CATALOG = 'tinytdstest' 
+          AND TABLE_TYPE = 'BASE TABLE' 
+          AND TABLE_NAME = 'datatypes'
+        ) DROP TABLE [datatypes]
+        IF EXISTS (
+          SELECT name FROM sysobjects 
+          WHERE name = 'tinytds_TestReturnCodes' AND type = 'P'
+        ) DROP PROCEDURE tinytds_TestReturnCodes|
+    end
+    
+    def sp_sql
+      %|CREATE PROCEDURE tinytds_TestReturnCodes
+        AS
+        SELECT 1 as [one]
+        RETURN(420) |
+    end
+
+    def find_value(id, column, query_options={})
+      query_options[:timezone] ||= :utc
+      sql = "SELECT [#{column}] FROM [datatypes] WHERE [id] = #{id}"
+      @client.execute(sql).each(query_options).first[column.to_s]
+    end
+    
+    def local_offset
+      TinyTds::Client.local_offset
+    end
+    
+    def utc_offset
+      ::Time.local(2010).utc_offset
+    end
+    
+    def rollback_transaction(client)
+      client.execute("BEGIN TRANSACTION").do
+      yield
+    ensure
+      client.execute("ROLLBACK TRANSACTION").do
+    end
+    
+    
+  end
+end
+