rdo-postgres 0.0.1

data/spec/postgres/driver_spec.rb

@@ -0,0 +1,285 @@
+require "spec_helper"
+require "uri"
+
+describe RDO::Postgres::Driver do
+  let(:options)    { connection_uri }
+  let(:connection) { RDO.connect(options) }
+
+  after(:each) { connection.close rescue nil }
+
+  describe "#initialize" do
+    context "with valid settings" do
+      it "opens a connection to the server" do
+        connection.should be_open
+      end
+    end
+
+    context "with invalid settings" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.user = "bad_user"}.to_s }
+
+      it "raises a RDO::Exception" do
+        expect { connection }.to raise_error(RDO::Exception)
+      end
+
+      it "provides a meaningful error message" do
+        begin
+          connection && fail("RDO::Exception should be raised")
+        rescue RDO::Exception => e
+          e.message.should =~ /\bbad_user\b/
+        end
+      end
+    end
+  end
+
+  describe "#close" do
+    it "closes the connection to the database" do
+      connection.close
+      connection.should_not be_open
+    end
+
+    it "returns true" do
+      connection.close.should be_true
+    end
+
+    context "called multiple times" do
+      it "has no negative side-effects" do
+        5.times { connection.close }
+        connection.should_not be_open
+      end
+    end
+  end
+
+  describe "#open" do
+    it "re-opens the connection to the database" do
+      connection.close && connection.open
+      connection.should be_open
+    end
+
+    it "returns true" do
+      connection.close
+      connection.open.should be_true
+    end
+
+    context "called multiple times" do
+      it "has no negative side-effects" do
+        connection.close
+        5.times { connection.open }
+        connection.should be_open
+      end
+    end
+  end
+
+  describe "#execute" do
+    after(:each) do
+      connection.execute("DROP SCHEMA IF EXISTS rdo_test CASCADE")
+    end
+
+    context "with DDL" do
+      let(:result) do
+        connection.execute("CREATE SCHEMA rdo_test")
+      end
+
+      it "returns a RDO::Result" do
+        result.should be_a_kind_of(RDO::Result)
+      end
+    end
+
+    context "with a bad query" do
+      let(:command) { connection.execute("SOME GIBBERISH") }
+
+      it "raises a RDO::Exception" do
+        expect { command }.to raise_error(RDO::Exception)
+      end
+
+      it "provides a meaningful error message" do
+        begin
+          command && fail("RDO::Exception should be raised")
+        rescue RDO::Exception => e
+          e.message.should =~ /\bSOME\b/
+        end
+      end
+    end
+
+    context "with an INSERT" do
+      before(:each) do
+        connection.execute("CREATE SCHEMA rdo_test")
+        connection.execute("SET search_path = rdo_test")
+        connection.execute(
+          "CREATE TABLE users (id serial primary key, name text)"
+        )
+      end
+
+      context "returning rows" do
+        let(:result) do
+          connection.execute(
+            "INSERT INTO users (name) VALUES ('bob') RETURNING *"
+          )
+        end
+
+        it "returns a RDO::Result" do
+          result.should be_a_kind_of(RDO::Result)
+        end
+
+        it "provides the return values" do
+          result.first[:id].should == 1
+          result.first[:name].should == "bob"
+        end
+
+        it "provides the #insert_id" do
+          result.insert_id.should == 1
+        end
+
+        it "provides the number of #affected_rows" do
+          result.affected_rows.should == 1
+        end
+      end
+
+      context "not returning" do
+        let(:result) do
+          connection.execute("INSERT INTO users (name) VALUES ('bob')")
+        end
+
+        it "returns a RDO::Result" do
+          result.should be_a_kind_of(RDO::Result)
+        end
+
+        it "has a nil #insert_id" do
+          result.insert_id.should be_nil
+        end
+
+        it "provides the number of #affected_rows" do
+          result.affected_rows.should == 1
+        end
+      end
+
+      context "using bind parameters" do
+        let(:result) do
+          connection.execute("INSERT INTO users (name) VALUES (?)", "bob")
+        end
+
+        it "returns a RDO::Result" do
+          result.should be_a_kind_of(RDO::Result)
+        end
+
+        it "provides the number of #affected_rows" do
+          result.affected_rows.should == 1
+        end
+      end
+    end
+
+    context "with a SELECT" do
+      before(:each) do
+        connection.execute("CREATE SCHEMA rdo_test")
+        connection.execute("SET search_path = rdo_test")
+      end
+
+      context "returning no rows" do
+        let(:result) { connection.execute("SELECT unnest('{}'::text[])") }
+
+        it "returns a RDO::Result" do
+          result.should be_a_kind_of(RDO::Result)
+        end
+
+        it "has no tuples" do
+          result.count.should == 0
+        end
+
+        it "can be converted to an empty array" do
+          result.to_a.should == []
+        end
+      end
+
+      context "returning rows" do
+        before(:each) do
+          connection.execute(
+            "CREATE TABLE users (id serial primary key, name text)"
+          )
+          connection.execute("INSERT INTO users (name) VALUES ('bob'), ('barry')")
+        end
+
+        let(:result) { connection.execute("SELECT * FROM users") }
+
+        it "returns a RDO::Result" do
+          result.should be_a_kind_of(RDO::Result)
+        end
+
+        it "provides the row count" do
+          result.count.should == 2
+        end
+
+        it "allows enumeration of the rows" do
+          rows = []
+          result.each{|row| rows << row }
+          rows.should == [{id: 1, name: "bob"}, {id: 2, name: "barry"}]
+        end
+
+        context "using bind parameters" do
+          let(:result) do
+            connection.execute("SELECT * FROM users WHERE name = ?", "barry")
+          end
+
+          it "returns a RDO::Result" do
+            result.should be_a_kind_of(RDO::Result)
+          end
+
+          it "provides the correct count" do
+            result.count.should == 1
+          end
+
+          it "allows enumeration of the rows" do
+            rows = []
+            result.each{|row| rows << row}
+            rows.should == [{id: 2, name: "barry"}]
+          end
+        end
+      end
+    end
+  end
+
+  describe "string encoding" do
+    context "with utf-8" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=utf-8"}.to_s }
+
+      it "returns utf-8 strings" do
+        connection.execute("SELECT 'foo'::text").first_value.encoding.should ==
+          Encoding.find("utf-8")
+      end
+    end
+
+    context "with iso-8859-1" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=iso-8859-1"}.to_s }
+
+      it "returns iso-8859-1 strings" do
+        connection.execute("SELECT 'foo'::text").first_value.encoding.should ==
+          Encoding.find("iso-8859-1")
+      end
+    end
+
+    context "with latin1" do
+      let(:options) { URI.parse(connection_uri).tap{|u| u.query = "encoding=latin1"}.to_s }
+
+      it "returns ascii-8bit strings (ruby doesn't know this charset)" do
+        connection.execute("SELECT 'foo'::text").first_value.encoding.should ==
+          Encoding.find("binary")
+      end
+    end
+  end
+
+  describe "#quote" do
+    it "quotes a string literal for insertion into the SQL" do
+      connection.quote("what's this?").should == "what''s this?"
+    end
+  end
+
+  describe "#prepare" do
+    it "returns a RDO::Statement" do
+      connection.prepare("SELECT ?::text").should be_a_kind_of(RDO::Statement)
+    end
+
+    it "can be executed multiple times" do
+      stmt = connection.prepare("SELECT ?::integer + ?")
+      stmt.execute(4, 7).first_value.should == 11
+      stmt.execute(5, 22).first_value.should == 27
+    end
+  end
+end

data/spec/postgres/type_cast_spec.rb

@@ -0,0 +1,272 @@
+require "spec_helper"
+
+describe RDO::Postgres::Driver, "type casting" do
+  let(:options)    { connection_uri }
+  let(:connection) { RDO.connect(options) }
+  let(:value)      { connection.execute(sql).first_value }
+
+  after(:each) { connection.close rescue nil }
+
+  describe "null cast" do
+    let(:sql) { "SELECT null" }
+
+    it "returns nil" do
+      value.should be_nil
+    end
+  end
+
+  describe "integer cast" do
+    let(:sql) { "SELECT 42::integer" }
+
+    it "returns a Fixnum" do
+      value.should == 42
+    end
+
+    context "using smallint" do
+      let(:sql) { "SELECT 42::smallint" }
+
+      it "returns a Fixnum" do
+        value.should == 42
+      end
+    end
+
+    context "using bigint" do
+      let(:sql) { "SELECT 42::bigint" }
+
+      it "returns a Fixnum" do
+        value.should == 42
+      end
+    end
+  end
+
+  describe "text cast" do
+    let(:sql) { "SELECT 42::text" }
+
+    it "returns a String" do
+      value.should == "42"
+    end
+  end
+
+  describe "varchar cast" do
+    let(:sql) { "SELECT 'a very long string'::varchar(10)" }
+
+    it "returns a String" do
+      value.should == "a very lon"
+    end
+  end
+
+  describe "char cast" do
+    let(:sql) { "SELECT 'a very long string'::char(10)" }
+
+    it "returns a String" do
+      value.should == "a very lon"
+    end
+  end
+
+  describe "boolean cast" do
+    describe "true" do
+      let(:sql) { "SELECT true" }
+
+      it "returns true" do
+        value.should == true
+      end
+    end
+
+    describe "false" do
+      let(:sql) { "SELECT false" }
+
+      it "returns false" do
+        value.should == false
+      end
+    end
+  end
+
+  describe "bytea cast" do
+    let(:sql) { "SELECT decode('00112233', 'hex')::bytea" }
+
+    context "using bytea_output = hex" do
+      before(:each) { connection.execute("SET bytea_output = hex") }
+
+      it "returns a String" do
+        value.should == "\x00\x11\x22\x33"
+      end
+    end
+
+    context "using bytea_output = escape" do
+      before(:each) do
+        # don't error on older versions of postgresql
+        connection.execute("SET bytea_output = escape") rescue nil
+      end
+
+      it "returns a String" do
+        value.should == "\x00\x11\x22\x33"
+      end
+    end
+  end
+
+  describe "float cast" do
+    let(:sql) { "SELECT 1.2::float" }
+
+    it "returns a Float" do
+      value.should be_a_kind_of(Float)
+      value.should <= 1.201
+      value.should >= 1.199
+    end
+
+    context "using real" do
+      let(:sql) { "SELECT 1.2::real" }
+
+      it "returns a Float" do
+        value.should be_a_kind_of(Float)
+        value.should <= 1.201
+        value.should >= 1.199
+      end
+    end
+
+    context "using double precision" do
+      let(:sql) { "SELECT 1.2::double precision" }
+
+      it "returns a Float" do
+        value.should be_a_kind_of(Float)
+        value.should <= 1.201
+        value.should >= 1.199
+      end
+    end
+
+    context "for 'NaN'" do
+      let(:sql) { "SELECT 'NaN'::float" }
+
+      it "returns Float::NAN" do
+        value.should be_a_kind_of(Float)
+        value.should be_nan
+      end
+    end
+
+    context "for 'Infinity'" do
+      let(:sql) { "SELECT 'Infinity'::float" }
+
+      it "returns Float::INFINITY" do
+        value.should  == Float::INFINITY
+      end
+    end
+
+    context "for '-Infinity'" do
+      let(:sql) { "SELECT '-Infinity'::float" }
+
+      it "returns -Float::INFINITY" do
+        value.should  == -Float::INFINITY
+      end
+    end
+
+    context "for '1E-06'" do
+      let(:sql) { "SELECT '1E-06'::float" }
+
+      it "returns 1e-06" do
+        value.should be_a_kind_of(Float)
+        value.should >= Float("1E-06") - 0.01
+        value.should <= Float("1E-06") + 0.01
+      end
+    end
+  end
+
+  describe "decimal cast" do
+    require "bigdecimal"
+
+    %w[decimal numeric].each do |type|
+      context "as #{type}" do
+        context "using a max precision and scale" do
+          let(:sql) { "SELECT '124.36'::#{type}(5,2)" }
+
+          it "returns a BigDecimal" do
+            value.should == BigDecimal("124.36")
+          end
+        end
+
+        context "using a max precision only" do
+          let(:sql) { "SELECT '124.36'::#{type}(5)" }
+
+          it "returns a BigDecimal" do
+            value.should == BigDecimal("124")
+          end
+        end
+
+        context "using no precision or scale" do
+          let(:sql) { "SELECT '124.36'::#{type}" }
+
+          it "returns a BigDecimal" do
+            value.should == BigDecimal("124.36")
+          end
+        end
+
+        context "for 'NaN'" do
+          let(:sql) { "SELECT 'NaN'::#{type}" }
+
+          it "returns a BigDecimal" do
+            value.should be_a_kind_of(BigDecimal)
+            value.should be_nan
+          end
+        end
+      end
+    end
+  end
+
+  describe "date cast" do
+    context "with YYYY-MM-DD format date" do
+      let(:sql) { "SELECT '2012-09-22'::date" }
+
+      it "returns a Date" do
+        value.should == Date.new(2012, 9, 22)
+      end
+    end
+
+    context "with YYY-MM-DD AD format date" do
+      let(:sql) { "SELECT '432-09-22 AD'::date" }
+
+      it "returns a Date" do
+        value.should == Date.new(432, 9, 22)
+      end
+    end
+
+    context "with YYY-MM-DD BC format date" do
+      let(:sql) { "SELECT '432-09-22 BC'::date" }
+
+      it "returns a Date" do
+        value.should == Date.new(-431, 9, 22)
+      end
+    end
+  end
+
+  describe "timestamp cast" do
+    context "without a time zone" do
+      let(:sql) { "SELECT '2012-09-22 04:26:34'::timestamp" }
+
+      it "returns a DateTime in the local time zone" do
+        value.should == DateTime.new(2012, 9, 22, 4, 26, 34, DateTime.now.zone)
+      end
+    end
+
+    context "with a time zone" do
+      let(:sql) { "SELECT '2012-09-22 04:26:34'::timestamptz" }
+
+      it "returns a DateTime, in the server's time zone" do
+        value.should == DateTime.new(2012, 9, 22, 4, 26, 34, DateTime.now.zone)
+      end
+
+      context "specifying an alternate time zone" do
+        let(:sql) { "SELECT '2012-09-22 04:26:34'::timestamptz at time zone 'UTC'" }
+
+        it "returns a DateTime at the given time zone" do
+          value.should == DateTime.new(2012, 9, 21, 18, 26, 34, DateTime.now.zone)
+        end
+      end
+
+      context "with a different time zone set on the connection" do
+        before(:each) { connection.execute("SET timezone = 'UTC'") }
+
+        it "returns a DateTime with the conversion done accordingly" do
+          value.should == DateTime.new(2012, 9, 22, 14, 26, 34, DateTime.now.zone)
+        end
+      end
+    end
+  end
+end