monetdb 0.1.3 → 0.2.0

data/test/unit/connection/test_query.rb

@@ -0,0 +1,276 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Connection
+    class TestQuery < MiniTest::Test
+
+      class Connection < SimpleConnection
+        include MonetDB::Connection::Messages
+        include MonetDB::Connection::Query
+      end
+
+      describe MonetDB::Connection::Query do
+        before do
+          @connection = Connection.new
+        end
+
+        describe "#extract_headers!" do
+          it "returns an array with delegated return values" do
+            response, foo, bar = mock, mock, mock
+
+            @connection.expects(:parse_query_header!).with(response).returns(foo)
+            @connection.expects(:parse_scheme_header!).with(response).returns(bar)
+
+            assert_equal [foo, bar], @connection.send(:extract_headers!, response)
+          end
+        end
+
+        describe "#parse_query_header!" do
+          describe "containing an error message" do
+            it "raises a query error" do
+              assert_raises MonetDB::QueryError do
+                @connection.send(:parse_query_header!, ["!epicfail", "foo"])
+              end
+            end
+          end
+
+          describe "when absent in response" do
+            it "raises a query error" do
+              assert_raises MonetDB::QueryError do
+                @connection.send(:parse_query_header!, ["$money", "foo"])
+              end
+            end
+          end
+
+          describe "when present in response" do
+            it "extracts the first line from the response and returns to_query_header_hash" do
+              response = [
+                "& 1 8 1982 0",
+                "% foo",
+                "% bar",
+                "[ 19, 82 ]",
+                "[ 20, 47 ]"
+              ]
+
+              @connection.expects(:to_query_header_hash).returns(hash = "hash")
+              assert_equal hash, @connection.send(:parse_query_header!, response)
+              assert_equal [
+                "% foo",
+                "% bar",
+                "[ 19, 82 ]",
+                "[ 20, 47 ]"
+              ], response
+            end
+          end
+        end
+
+        describe "#to_query_header_hash" do
+          describe "when Q_TABLE header" do
+            it "returns a table header hash" do
+              assert_equal({
+                :type => "1",
+                :id => 0,
+                :rows => 1947,
+                :columns => 8,
+                :returned => 2014
+              }, @connection.send(:to_query_header_hash, "&1 0 1947 8 2014"))
+            end
+          end
+          describe "when Q_BLOCK header" do
+            it "returns a block header hash" do
+              assert_equal({
+                :type => "6",
+                :id => 0,
+                :columns => 10,
+                :remains => 179,
+                :offset => 100
+              }, @connection.send(:to_query_header_hash, "&6 0 10 179 100"))
+            end
+          end
+          describe "when unknown header" do
+            it "returns a simple hash with just the type" do
+              assert_equal({:type => "0"}, @connection.send(:to_query_header_hash, "&0 1 2 3"))
+            end
+          end
+        end
+
+        describe "#parse_scheme_header!" do
+          describe "when present in response" do
+            it "extracts scheme related lines from the response and returns to_scheme_header_hash" do
+              response = [
+                "% foo",
+                "% bar",
+                "[ 19, 82 ]",
+                "[ 20, 47 ]"
+              ]
+
+              @connection.expects(:to_scheme_header_hash).returns(hash = "hash")
+              assert_equal hash, @connection.send(:parse_scheme_header!, response)
+              assert_equal [
+                "[ 19, 82 ]",
+                "[ 20, 47 ]"
+              ], response
+            end
+          end
+
+          describe "when absent in response" do
+            it "returns nil" do
+              response = [
+                "[ 19, 82 ]",
+                "% foo bar",
+                "[ 20, 47 ]"
+              ]
+              assert_nil @connection.send(:parse_scheme_header!, response)
+              assert_equal [
+                "[ 19, 82 ]",
+                "% foo bar",
+                "[ 20, 47 ]"
+              ], response
+            end
+          end
+        end
+
+        describe "#to_scheme_header_hash" do
+          it "returns a frozen hash" do
+            header = [
+              %w(foo_bars baz_quxs paul_engels),
+              %w(foo bar baz qux),
+              %w(tinyint varchar integer float),
+              %w(1 9 8 2)
+            ]
+
+            hash = @connection.send(:to_scheme_header_hash, header)
+
+            assert_equal true, hash.frozen?
+            assert_equal({
+              :table_name => "foo_bars",
+              :column_names => %w(foo bar baz qux),
+              :column_types => [:tinyint, :varchar, :integer, :float],
+              :column_lengths => [1, 9, 8, 2]
+            }, hash)
+          end
+        end
+
+        describe "#parse_rows" do
+          it "returns an array of hashes" do
+            table_header = {
+              :column_types => [:varchar, :date, :double]
+            }
+
+            response = [
+              "[ \"Paul Engel\",\t1982-08-01,\t19.82\t]",
+              "[ \"Ken Adams\",\t1980-10-13,\t20.47\t]"
+            ].join("\n")
+
+            assert_equal [
+              ["Paul Engel", Date.parse("1982-08-01"), 19.82],
+              ["Ken Adams", Date.parse("1980-10-13"), 20.47]
+            ], @connection.send(:parse_rows, table_header, response)
+          end
+        end
+
+        describe "#parse_value" do
+          describe "when NULL" do
+            it "returns nil" do
+              assert_nil @connection.send(:parse_value, :varchar, "NULL")
+              assert_nil @connection.send(:parse_value, :text, "NULL")
+              assert_nil @connection.send(:parse_value, :int, "NULL")
+              assert_nil @connection.send(:parse_value, :smallint, "NULL")
+              assert_nil @connection.send(:parse_value, :bigint, "NULL")
+              assert_nil @connection.send(:parse_value, :double, "NULL")
+              assert_nil @connection.send(:parse_value, :float, "NULL")
+              assert_nil @connection.send(:parse_value, :real, "NULL")
+              assert_nil @connection.send(:parse_value, :date, "NULL")
+              assert_nil @connection.send(:parse_value, :timestamp, "NULL")
+              assert_nil @connection.send(:parse_value, :tinyint, "NULL")
+            end
+          end
+
+          describe "when not NULL" do
+            describe "when is type valid" do
+              it "delegates to the appropiate parse method" do
+                value = mock
+
+                @connection.expects(:parse_string_value).with(value)
+                @connection.send(:parse_value, :varchar, value)
+
+                @connection.expects(:parse_string_value).with(value)
+                @connection.send(:parse_value, :text, value)
+
+                @connection.expects(:parse_integer_value).with(value)
+                @connection.send(:parse_value, :int, value)
+
+                @connection.expects(:parse_integer_value).with(value)
+                @connection.send(:parse_value, :smallint, value)
+
+                @connection.expects(:parse_integer_value).with(value)
+                @connection.send(:parse_value, :bigint, value)
+
+                @connection.expects(:parse_float_value).with(value)
+                @connection.send(:parse_value, :float, value)
+
+                @connection.expects(:parse_float_value).with(value)
+                @connection.send(:parse_value, :real, value)
+
+                @connection.expects(:parse_date_value).with(value)
+                @connection.send(:parse_value, :date, value)
+
+                @connection.expects(:parse_date_time_value).with(value)
+                @connection.send(:parse_value, :timestamp, value)
+
+                @connection.expects(:parse_boolean_value).with(value)
+                @connection.send(:parse_value, :tinyint, value)
+              end
+            end
+
+            describe "when is type invalid" do
+              it "raises a not implemented error" do
+                assert_raises NotImplementedError do
+                  @connection.send(:parse_value, :foo, mock)
+                end
+              end
+            end
+          end
+        end
+
+        describe "#parse_string_value" do
+          it "returns a string" do
+            assert_equal "Paul Engel", @connection.send(:parse_string_value, "\"Paul Engel\"")
+          end
+        end
+
+        describe "#parse_integer_value" do
+          it "returns an integer" do
+            assert_equal 1982, @connection.send(:parse_integer_value, "1982")
+          end
+        end
+
+        describe "#parse_float_value" do
+          it "returns a float" do
+            assert_equal 19.82, @connection.send(:parse_float_value, "19.82")
+          end
+        end
+
+        describe "#parse_date_value" do
+          it "returns a Date instance" do
+            assert_equal Date.parse("1982-08-01"), @connection.send(:parse_date_value, "1982-08-01")
+          end
+        end
+
+        describe "#parse_date_time_value" do
+          it "returns a Time instance" do
+            assert_equal Time.parse("1982-08-01 18:19:47"), @connection.send(:parse_date_time_value, "1982-08-01 18:19:47.0000")
+          end
+        end
+
+        describe "#parse_boolean_value" do
+          it "returns a boolean" do
+            assert_equal false, @connection.send(:parse_boolean_value, "0")
+            assert_equal true, @connection.send(:parse_boolean_value, "1")
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/connection/test_setup.rb

@@ -0,0 +1,364 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Connection
+    class TestSetup < MiniTest::Test
+
+      class Connection < SimpleConnection
+        include MonetDB::Connection::Messages
+        include MonetDB::Connection::Setup
+      end
+
+      describe MonetDB::Connection::Setup do
+        before do
+          @connection = Connection.new
+        end
+
+        describe "#setup" do
+          it "obtains the server challenge, sets up the timezone and reply size" do
+            @connection.expects(:authenticate)
+            @connection.expects(:set_timezone_interval)
+            @connection.expects(:set_reply_size)
+            @connection.send(:setup)
+          end
+        end
+
+        describe "#authenticate" do
+          before do
+            @connection.expects(:obtain_server_challenge!)
+            @connection.expects(:authentication_string).returns(auth_string = "<authentication_string>")
+            @connection.expects(:write).with(auth_string)
+          end
+
+          describe "when success" do
+            it "returns true" do
+              @connection.expects(:read).returns("")
+              @connection.send(:authenticate)
+            end
+          end
+
+          describe "when redirect" do
+            it "authenticates using the redirect" do
+              @connection.expects(:read).returns(response = "^^mapi:redirect")
+              @connection.expects(:authentication_redirect).with(response)
+              @connection.send(:authenticate)
+            end
+          end
+
+          describe "when fail" do
+            it "raises an authentication error" do
+              @connection.expects(:read).returns("!epicfail")
+              assert_raises MonetDB::AuthenticationError do
+                @connection.send(:authenticate)
+              end
+            end
+          end
+        end
+
+        describe "#obtain_server_challenge!" do
+          it "updates the config and validates it" do
+            @connection.expects(:server_challenge).returns(:foo => "bar", :baz => "qux")
+            @connection.expects(:assert_supported_protocol!)
+            @connection.expects(:select_supported_auth_type!)
+
+            assert_equal({
+              :host => "localhost",
+              :port => 50000,
+              :username => "monetdb",
+              :password => "monetdb"
+            }, @connection.instance_variable_get(:@config))
+
+            @connection.send(:obtain_server_challenge!)
+
+            assert_equal({
+              :host => "localhost",
+              :port => 50000,
+              :username => "monetdb",
+              :password => "monetdb",
+              :foo => "bar",
+              :baz => "qux"
+            }, @connection.instance_variable_get(:@config))
+          end
+        end
+
+        describe "#server_challenge" do
+          it "returns the server challenge config" do
+            response = "<salt>:<server_name>:9:MD5,SHA512:<server_endianness>:SHA1"
+            @connection.expects(:read).returns(response)
+            assert_equal({
+              :salt => "<salt>",
+              :server_name => "<server_name>",
+              :protocol => "9",
+              :auth_types => "MD5,SHA512",
+              :server_endianness => "<server_endianness>",
+              :password_digest_method => "SHA1"
+            }, @connection.send(:server_challenge))
+          end
+        end
+
+        describe "#assert_supported_protocol!" do
+          describe "when supporting one of the server protocols" do
+            it "returns nil" do
+              @connection.instance_variable_get(:@config)[:protocol] = MonetDB::Connection::MAPI_V8
+              assert_nil @connection.send(:assert_supported_protocol!)
+            end
+          end
+
+          describe "when not supporting any of the server protocols" do
+            it "raises a protocol error" do
+              @connection.instance_variable_get(:@config)[:protocol] = "FOO"
+              assert_raises MonetDB::ProtocolError do
+                @connection.send(:assert_supported_protocol!)
+              end
+            end
+          end
+        end
+
+        describe "#select_supported_auth_type!" do
+          describe "when supporting one of the server authentication types" do
+            it "selects a supported authentication type" do
+              config = @connection.instance_variable_get(:@config)
+              auth_md5 = MonetDB::Connection::AUTH_MD5
+
+              config[:auth_types] = "FOO,#{auth_md5},BAR"
+              assert_nil config[:auth_type]
+
+              @connection.send(:select_supported_auth_type!)
+              assert_equal auth_md5, config[:auth_type]
+            end
+          end
+
+          describe "when not supporting any of the server authentication types" do
+            it "raises an authentication error" do
+              response = "<salt>:<server_name>:9:CRYPT:<server_endianness>:SHA1"
+              @connection.expects(:read).returns(response)
+              assert_raises MonetDB::AuthenticationError do
+                @connection.send(:obtain_server_challenge!)
+              end
+            end
+          end
+        end
+
+        describe "#authentication_string" do
+          before do
+            @endianness = MonetDB::Connection::ENDIANNESS
+            @lang = MonetDB::Connection::LANG
+            @connection.instance_variable_set :@config, {
+              :database => "db",
+              :username => "paul",
+              :password => "mysecret",
+              :salt => "kitchen",
+              :password_digest_method => "MD5"
+            }
+          end
+
+          describe "MAPI V8 protocol" do
+            before do
+              @connection.instance_variable_get(:@config)[:protocol] = MonetDB::Connection::MAPI_V8
+            end
+
+            describe "when using digests" do
+              it "returns an authentication string with a digest hashsum" do
+                @connection.instance_variable_get(:@config)[:auth_type] = "MD5"
+                hashsum = "ec2c417dbdaa6fec77eef74e8c2524b9"
+                assert_equal "#{@endianness}:paul:{MD5}#{hashsum}:#{@lang}:db:", @connection.send(:authentication_string)
+
+                @connection.instance_variable_get(:@config)[:auth_type] = "SHA1"
+                hashsum = "10cbdc8ea82154bbfe64df5265a2f35118b51a18"
+                assert_equal "#{@endianness}:paul:{SHA1}#{hashsum}:#{@lang}:db:", @connection.send(:authentication_string)
+
+                @connection.instance_variable_get(:@config)[:auth_type] = "SHA512"
+                hashsum = "8527a8feaa8ea3e538b16a1a40e76176edb725b29bb8989ec4800de625f6b1d3569eb7fae49b0b54ae33bbf055e462a769582d0f02a18181e5dac1b106710d98"
+                assert_equal "#{@endianness}:paul:{SHA512}#{hashsum}:#{@lang}:db:", @connection.send(:authentication_string)
+              end
+            end
+
+            describe "when plain authentication type" do
+              it "returns an authentication string with a plain hashsum" do
+                @connection.instance_variable_get(:@config)[:auth_type] = "PLAIN"
+                assert_equal "#{@endianness}:paul:{PLAIN}mysecretkitchen:#{@lang}:db:", @connection.send(:authentication_string)
+              end
+            end
+
+            describe "when non-supported authentication type" do
+              it "returns an authentication string without hashsum" do
+                assert_equal "#{@endianness}:paul:{}:#{@lang}:db:", @connection.send(:authentication_string)
+              end
+            end
+          end
+
+          describe "MAPI V9 protocol" do
+            before do
+              @connection.instance_variable_get(:@config)[:protocol] = MonetDB::Connection::MAPI_V9
+              @connection.instance_variable_get(:@config)[:password_digest_method] = "MD5"
+            end
+
+            describe "when using digests" do
+              it "returns an authentication string with a digest hashsum" do
+                @connection.instance_variable_get(:@config)[:auth_type] = "MD5"
+                hashsum = "2c89f883c0a9e30f58585f15adeb0500"
+                assert_equal "#{@endianness}:paul:{MD5}#{hashsum}:#{@lang}:db:", @connection.send(:authentication_string)
+
+                @connection.instance_variable_get(:@config)[:auth_type] = "SHA1"
+                hashsum = "51f0d237aedd38ad10f3348ecaa95d1d9fc7d7fd"
+                assert_equal "#{@endianness}:paul:{SHA1}#{hashsum}:#{@lang}:db:", @connection.send(:authentication_string)
+
+                @connection.instance_variable_get(:@config)[:auth_type] = "SHA512"
+                hashsum = "cf623a200ef12a7413835745bd0287cba478f1eb275c57137f7bdcea20ec10897544ad7a45647c3b814ff9e9e2fb187e6277fe2f994b23bb7d09f2141f83fffa"
+                assert_equal "#{@endianness}:paul:{SHA512}#{hashsum}:#{@lang}:db:", @connection.send(:authentication_string)
+              end
+            end
+
+            describe "when plain authentication type" do
+              it "returns an authentication string with a plain hashsum" do
+                @connection.instance_variable_get(:@config)[:auth_type] = "PLAIN"
+                assert_equal "#{@endianness}:paul:{PLAIN}mysecretkitchen:#{@lang}:db:", @connection.send(:authentication_string)
+              end
+            end
+
+            describe "when non-supported authentication type" do
+              it "returns an authentication string without hashsum" do
+                assert_equal "#{@endianness}:paul:{}:#{@lang}:db:", @connection.send(:authentication_string)
+              end
+            end
+          end
+        end
+
+        describe "#hexdigest" do
+          it "returns the hexdigest using the passed method and value" do
+            assert_equal "acbd18db4cc2f85cedef654fccc4a4d8", @connection.send(:hexdigest, "MD5", "foo")
+            assert_equal "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", @connection.send(:hexdigest, "SHA1", "foo")
+            assert_equal "f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7", @connection.send(:hexdigest, "SHA512", "foo")
+          end
+        end
+
+        describe "#authentication_redirect" do
+          describe "without a MAPI redirect" do
+            it "raises an authentication error" do
+              assert_raises MonetDB::AuthenticationError do
+                @connection.send(:authentication_redirect, "^foobar:bazqux")
+              end
+            end
+          end
+
+          describe "without a valid redirect URI" do
+            it "raises an authentication error" do
+              URI.expects(:split).raises(URI::InvalidURIError)
+              assert_raises MonetDB::AuthenticationError do
+                @connection.send(:authentication_redirect, "^mapi:foobar")
+              end
+            end
+          end
+
+          describe "with 'merovingian' scheme" do
+            it "retries to authenticate" do
+              @connection.expects(:authenticate)
+              @connection.send(:authentication_redirect, "^mapi:merovingian://foobar")
+            end
+
+            describe "when too many retries" do
+              it "raises an authentication error" do
+                @connection.expects(:obtain_server_challenge!).times(5)
+                @connection.expects(:write).times(5)
+                @connection.expects(:read).times(5).returns(response = "^mapi:merovingian://foobar")
+                assert_raises MonetDB::AuthenticationError do
+                  @connection.send(:authentication_redirect, response)
+                end
+              end
+            end
+          end
+
+          describe "with 'monetdb' scheme" do
+            it "raises an authentication error" do
+              @connection.expects(:connect)
+              @connection.send(:authentication_redirect, "^mapi:monetdb://ghost:1982")
+              assert_equal "ghost", @connection.send(:config)[:host]
+              assert_equal "1982", @connection.send(:config)[:port]
+            end
+          end
+
+          describe "without a supported server name" do
+            it "raises an authentication error" do
+              assert_raises MonetDB::AuthenticationError do
+                @connection.send(:authentication_redirect, "^mapi:foobar")
+              end
+            end
+          end
+        end
+
+        describe "#set_timezone_interval" do
+          describe "when not already set" do
+            describe "when success" do
+              it "returns true" do
+                time = mock
+                time.expects(:gmt_offset).returns(7200)
+                Time.expects(:now).returns(time)
+
+                @connection.expects(:write).with("sSET TIME ZONE INTERVAL '+02:00' HOUR TO MINUTE;")
+                @connection.expects(:read).returns("")
+                assert_equal true, @connection.send(:set_timezone_interval)
+
+                @connection.instance_variable_set(:@timezone_interval_set, false)
+
+                time = mock
+                time.expects(:gmt_offset).returns(36000)
+                Time.expects(:now).returns(time)
+
+                @connection.expects(:write).with("sSET TIME ZONE INTERVAL '+10:00' HOUR TO MINUTE;")
+                @connection.expects(:read).returns("")
+                assert_equal true, @connection.send(:set_timezone_interval)
+              end
+            end
+
+            describe "when fail" do
+              it "raises a command error" do
+                @connection.expects(:write)
+                @connection.expects(:read).returns("!epicfail")
+                assert_raises MonetDB::CommandError do
+                  @connection.send(:set_timezone_interval)
+                end
+              end
+            end
+          end
+
+          describe "when already set" do
+            it "returns false" do
+              @connection.instance_variable_set(:@timezone_interval_set, true)
+              assert_equal false, @connection.send(:set_timezone_interval)
+            end
+          end
+        end
+
+        describe "#set_reply_size" do
+          describe "when not already set" do
+            describe "when success" do
+              it "returns true" do
+                @connection.expects(:write).with("Xreply_size #{MonetDB::Connection::REPLY_SIZE}\n")
+                @connection.expects(:read).returns("")
+                assert_equal true, @connection.send(:set_reply_size)
+              end
+            end
+
+            describe "when fail" do
+              it "raises a command error" do
+                @connection.expects(:write)
+                @connection.expects(:read).returns("!epicfail")
+                assert_raises MonetDB::CommandError do
+                  @connection.send(:set_reply_size)
+                end
+              end
+            end
+          end
+
+          describe "when already set" do
+            it "returns false" do
+              @connection.instance_variable_set(:@reply_size_set, true)
+              assert_equal false, @connection.send(:set_reply_size)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end