rdo-postgres 0.0.6 → 0.0.7

data/spec/postgres/array/bytea_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::Bytea do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::Bytea.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::Bytea[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of Strings" do
+      let(:arr) { RDO::Postgres::Array::Bytea["\x00\x11", "\x22\x33", "\x44\x55"] }
+
+      it "escapes the binary data" do
+        if arr.to_s =~ /\\x/
+          arr.to_s.should == '{"\\x00\\x11","\\x22\\x33","\\x44\\x55"}'
+        else
+          arr.to_s.should == '{"\\\\000\\\\021","\\"3","DU"}'
+        end
+      end
+
+      context "containing nil" do
+        let(:arr) { RDO::Postgres::Array::Bytea["\x00\x11", nil] }
+
+        it "uses NULL" do
+          if arr.to_s =~ /\\x/
+            arr.to_s.should == '{"\\x00\\x11",NULL}'
+          else
+            arr.to_s.should == '{"\\\\000\\\\021",NULL}'
+          end
+        end
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::Bytea["\x00\x11", "\x22\x33", "\x44\x55"] }
+
+    it "returns a Ruby ::Array" do
+      arr.to_a.should == ["\x00\x11", "\x22\x33", "\x44\x55"]
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::Bytea.parse(str) }
+
+    it "returns a RDO::Postgres::Array::Bytea" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::Bytea)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of byteas" do
+      let(:str) { '{"\\\\x0011","\\\\x2233"}' }
+
+      it "returns an Array of Strings" do
+        arr.to_a.should == ["\x00\x11", "\x22\x33"]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,NULL,"\\\\x0011"}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, nil, "\x00\x11"]
+      end
+    end
+  end
+end

data/spec/postgres/array/date_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::Date do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::Date.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::Date[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of Dates" do
+      let(:arr) { RDO::Postgres::Array::Date[Date.new(2012, 9, 22), Date.new(1983, 5, 3)] }
+
+      it "formats the dates in quotes" do
+        arr.to_s.should == '{"2012-09-22","1983-05-03"}'
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array::Date[nil, Date.new(1983, 5, 3)] }
+
+      it "uses NULL" do
+        arr.to_s.should == '{NULL,"1983-05-03"}'
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::Date[Date.new(2012, 9, 22), Date.new(1983, 5, 3)] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::Date.parse(str) }
+
+    it "returns a RDO::Postgres::Array::Date" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::Date)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of dates" do
+      let(:str) { '{"2012-09-22","1983-05-03"}' }
+
+      it "returns an Array of Dates" do
+        arr.to_a.should == [Date.new(2012, 9, 22), Date.new(1983, 5, 3)]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,"1983-05-03"}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, Date.new(1983, 5, 3)]
+      end
+    end
+  end
+end

data/spec/postgres/array/float_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::Float do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::Float.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::Float[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of Floats" do
+      let(:arr) { RDO::Postgres::Array::Float[1.2, 2.4, 3.6] }
+
+      it "comma separates the numbers" do
+        arr.to_s.should == '{1.2,2.4,3.6}'
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array::Float[nil, nil, 7.2] }
+
+      it "uses NULL" do
+        arr.to_s.should == '{NULL,NULL,7.2}'
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::Float[1.2, 2.4, 3.6] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::Float.parse(str) }
+
+    it "returns a RDO::Postgres::Array::Float" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::Float)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of floats" do
+      let(:str) { '{1.2,2.4,3.6}' }
+
+      it "returns an Array of Floats" do
+        arr.to_a.should == [1.2, 2.4, 3.6]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,NULL,7.2}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, nil, 7.2]
+      end
+    end
+
+    context "with an array containing NaN" do
+      let(:str) { '{NaN,7.2}' }
+
+      it "uses Float::NAN as the value" do
+        arr.to_a.should == [Float::NAN, 7.2]
+      end
+    end
+
+    context "with an array containing Infinity" do
+      let(:str) { '{Infinity,7.2}' }
+
+      it "uses Float::INFINITY as the value" do
+        arr.to_a.should == [Float::INFINITY, 7.2]
+      end
+    end
+
+    context "with an array containing -Infinity" do
+      let(:str) { '{-Infinity,7.2}' }
+
+      it "uses -Float::INFINITY as the value" do
+        arr.to_a.should == [-Float::INFINITY, 7.2]
+      end
+    end
+  end
+end

data/spec/postgres/array/integer_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::Integer do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::Integer.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::Integer[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of Fixnums" do
+      let(:arr) { RDO::Postgres::Array::Integer[1, 2, 3] }
+
+      it "comma separates the numbers" do
+        arr.to_s.should == '{1,2,3}'
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array::Integer[nil, nil, 7] }
+
+      it "uses NULL" do
+        arr.to_s.should == '{NULL,NULL,7}'
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::Integer[1, 2, 3] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::Integer.parse(str) }
+
+    it "returns a RDO::Postgres::Array::Integer" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::Integer)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of integers" do
+      let(:str) { '{1,2,3}' }
+
+      it "returns an Array of Fixnums" do
+        arr.to_a.should == [1, 2, 3]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,NULL,7}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, nil, 7]
+      end
+    end
+  end
+end

data/spec/postgres/array/numeric_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::Numeric do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::Numeric.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::Numeric[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of BigDecimals" do
+      let(:arr) { RDO::Postgres::Array::Numeric[BigDecimal("1.2"), BigDecimal("2.4")] }
+
+      it "comma separates the numbers" do
+        arr.to_s.should == "{#{BigDecimal('1.2').to_s},#{BigDecimal('2.4').to_s}}"
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array::Numeric[nil, BigDecimal("7.2")] }
+
+      it "uses NULL" do
+        arr.to_s.should == "{NULL,#{BigDecimal('7.2').to_s}}"
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::Numeric[BigDecimal("1.2"), BigDecimal("2.4")] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::Numeric.parse(str) }
+
+    it "returns a RDO::Postgres::Array::Numeric" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::Numeric)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of decimals" do
+      let(:str) { '{1.2,2.4}' }
+
+      it "returns an Array of BigDecimals" do
+        arr.to_a.should == [BigDecimal("1.2"), BigDecimal("2.4")]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,7.2}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, BigDecimal("7.2")]
+      end
+    end
+
+    context "with an array containing NaN" do
+      let(:str) { '{NaN,7.2}' }
+
+      it "uses BigDecimal('NaN') as the value" do
+        arr.to_a[0].should be_nan
+        arr.to_a[1].should == BigDecimal("7.2")
+      end
+    end
+  end
+end

data/spec/postgres/array/timestamp_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+
+describe RDO::Postgres::Array::Timestamp do
+  it "is a kind of ::Array" do
+    RDO::Postgres::Array::Timestamp.new.should be_a_kind_of(::Array)
+  end
+
+  describe "#to_s" do
+    context "with an empty array" do
+      let(:arr) { RDO::Postgres::Array::Timestamp[] }
+
+      it "returns {}" do
+        arr.to_s.should == '{}'
+      end
+    end
+
+    context "with an array of Times" do
+      let(:arr) { RDO::Postgres::Array::Timestamp[
+        Time.new(2012, 9, 22, 5, 43, 2),
+        Time.new(1983, 5, 3, 15, 0, 1)
+      ] }
+
+      it "formats the times in quotes" do
+        arr.to_s.should == %Q[{"#{Time.new(2012, 9, 22, 5, 43, 2)}","#{Time.new(1983, 5, 3, 15, 0, 1)}"}]
+      end
+    end
+
+    context "with an array containing nil" do
+      let(:arr) { RDO::Postgres::Array::Timestamp[nil, Time.new(1983, 5, 3, 0, 0, 1)] }
+
+      it "uses NULL" do
+        arr.to_s.should == %Q[{NULL,"#{Time.new(1983, 5, 3, 0, 0, 1)}"}]
+      end
+    end
+  end
+
+  describe "#to_a" do
+    let(:arr) { RDO::Postgres::Array::Timestamp[Time.new(2012, 9, 22, 0, 0, 0)] }
+
+    it "returns a core ruby Array" do
+      arr.to_a.class.should == ::Array
+    end
+  end
+
+  describe ".parse" do
+    let(:str) { '{}' }
+    let(:arr) { RDO::Postgres::Array::Timestamp.parse(str) }
+
+    it "returns a RDO::Postgres::Array::Timestamp" do
+      arr.should be_a_kind_of(RDO::Postgres::Array::Timestamp)
+    end
+
+    context "with an empty array string" do
+      let(:str) { '{}' }
+
+      it "returns an empty Array" do
+        arr.should be_empty
+      end
+    end
+
+    context "with an array of timestamps" do
+      let(:str) { '{"2012-09-22 05:34:01","1983-05-03 13:59:09"}' }
+
+      it "returns an Array of DateTimes" do
+        arr.to_a.should == [
+          DateTime.new(2012, 9, 22, 5, 34, 1, DateTime.now.zone),
+          DateTime.new(1983, 5, 3, 13, 59, 9, DateTime.now.zone)
+        ]
+      end
+    end
+
+    context "with an array containing NULL" do
+      let(:str) { '{NULL,"1983-05-03 00:04:05"}' }
+
+      it "uses nil as the value" do
+        arr.to_a.should == [nil, DateTime.new(1983, 5, 3, 0, 4, 5, DateTime.now.zone)]
+      end
+    end
+  end
+end