rdo 0.0.1

data/spec/rdo/connection_spec.rb

@@ -0,0 +1,220 @@
+require "spec_helper"
+
+describe RDO::Connection do
+  after(:each) { RDO::Connection.drivers.clear }
+
+  describe ".register_driver" do
+    before(:each) do
+      RDO::Connection.register_driver(:bob, RDO::Driver)
+    end
+
+    it "registers a driver name for a driver class" do
+      RDO::Connection.drivers["bob"].should == RDO::Driver
+    end
+  end
+
+  describe "#initialize" do
+    let(:driver)       { double(:driver, open: true) }
+    let(:driver_class) { double(new: driver) }
+
+    before(:each) { RDO::Connection.register_driver(:test, driver_class) }
+
+    context "with a connection uri string" do
+      context "for a registered driver" do
+        it "instantiates the driver" do
+          driver_class.should_receive(:new).and_return(driver)
+          RDO::Connection.new("test://whatever")
+        end
+
+        it "converts the uri to an options hash" do
+          driver_class.should_receive(:new).
+            with(hash_including(driver: "test")).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever")
+        end
+
+        it "parses the host name" do
+          driver_class.should_receive(:new).
+            with(hash_including(host: "whatever")).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever:3456")
+        end
+
+        it "parses the username" do
+          driver_class.should_receive(:new).
+            with(hash_including(user: "bob")).
+            and_return(driver)
+
+          RDO::Connection.new("test://bob:@whatever:3456")
+        end
+
+        it "parses the password" do
+          driver_class.should_receive(:new).
+            with(hash_including(password: "secret")).
+            and_return(driver)
+
+          RDO::Connection.new("test://user:secret@whatever:3456")
+        end
+
+        it "parses the port number" do
+          driver_class.should_receive(:new).
+            with(hash_including(port: 3456)).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever:3456")
+        end
+
+        it "parses the path" do
+          driver_class.should_receive(:new).
+            with(hash_including(path: "/some/path.db")).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever/some/path.db")
+        end
+
+        it "parses the database name" do
+          driver_class.should_receive(:new).
+            with(hash_including(database: "my_db")).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever/my_db")
+        end
+
+        it "parses the encoding" do
+          driver_class.should_receive(:new).
+            with(hash_including(encoding: "utf-8")).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever/my_db?encoding=utf-8")
+        end
+
+        it "parses driver-specific options" do
+          driver_class.should_receive(:new).
+            with(hash_including(special_mode: "true")).
+            and_return(driver)
+
+          RDO::Connection.new("test://whatever/my_db?encoding=utf-8&special_mode=true")
+        end
+
+        context "with only a path" do
+          it "parses the path" do
+            driver_class.should_receive(:new).
+              with(hash_including(path: "/some/path.db")).
+              and_return(driver)
+
+            RDO::Connection.new("test:/some/path.db")
+          end
+        end
+
+        it "invokes #open on the driver" do
+          driver.should_receive(:open).and_return(true)
+          RDO::Connection.new("test://host/db")
+        end
+      end
+
+      context "for an unknown driver" do
+        it "raises an RDO::Exception" do
+          expect {
+            RDO::Connection.new("wat://ever")
+          }.to raise_error(RDO::Exception)
+        end
+      end
+    end
+
+    context "with an options hash" do
+      context "for a registered driver" do
+        it "instantiates the driver" do
+          driver_class.should_receive(:new).and_return(driver)
+          RDO::Connection.new(driver: :test, host: "whatever")
+        end
+
+        it "passes the options to the driver" do
+          driver_class.should_receive(:new).
+            with(hash_including(host: "whatever")).
+            and_return(driver)
+          RDO::Connection.new(driver: :test, host: "whatever")
+        end
+
+        it "invokes #open on the driver" do
+          driver.should_receive(:open).and_return(true)
+          RDO::Connection.new(driver: :test, host: "whatever")
+        end
+      end
+
+      context "for an unknown driver" do
+        it "raises an RDO::Exception" do
+          expect {
+            RDO::Connection.new(driver: :wat, host: "test")
+          }.to raise_error(RDO::Exception)
+        end
+      end
+    end
+  end
+
+  describe "driver methods" do
+    let(:connection)   { RDO::Connection.new("test://host") }
+    let(:driver)       { double(:driver, open: true) }
+    let(:driver_class) { double(new: driver) }
+
+    before(:each) do
+      RDO::Connection.register_driver(:test, driver_class)
+      connection
+    end
+
+    describe "#open" do
+      it "delegates to the driver" do
+        driver.should_receive(:open).and_return(true)
+        connection.open.should == true
+      end
+    end
+
+    describe "#close" do
+      it "delegates to the driver" do
+        driver.should_receive(:close).and_return(true)
+        connection.close.should == true
+      end
+    end
+
+    describe "#open?" do
+      it "delegates to the driver" do
+        driver.should_receive(:open?).and_return(false)
+        connection.should_not be_open
+      end
+    end
+
+    describe "#execute" do
+      let(:result) { RDO::Result.new([]) }
+
+      it "delegates to the driver" do
+        driver.should_receive(:execute).
+          with("SELECT * FROM bob WHERE ?", true).
+          and_return(result)
+        connection.execute("SELECT * FROM bob WHERE ?", true).should == result
+      end
+    end
+
+    describe "#prepare" do
+      let(:stmt) { RDO::Statement.new(stub(:executor)) }
+
+      it "delegates to the driver" do
+        driver.should_receive(:prepare).
+          with("SELECT * FROM bob WHERE ?").
+          and_return(stmt)
+        connection.prepare("SELECT * FROM bob WHERE ?").should == stmt
+      end
+    end
+
+    describe "#quote" do
+      let(:quoted) { "Weird ['] quotes" }
+
+      it "delegates to the driver" do
+        driver.should_receive(:quote).
+          with("Weird ' quotes").
+          and_return(quoted)
+        connection.quote("Weird ' quotes").should == quoted
+      end
+    end
+  end
+end

data/spec/rdo/driver_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe RDO::Driver do
+  describe "#initialize" do
+    it "does not call #open" do
+      RDO::DriverWithEverything.new.should_not be_open
+    end
+  end
+
+  describe "#prepare" do
+    let(:driver) { RDO::DriverWithoutStatements.new }
+
+    it "returns a Statement" do
+      driver.prepare("SELECT * FROM bob WHERE ?").should be_a_kind_of(RDO::Statement)
+    end
+
+    it "has the correct command" do
+      driver.prepare("SELECT * FROM bob WHERE ?").command.should == "SELECT * FROM bob WHERE ?"
+    end
+
+    it "calls #execute on the driver" do
+      driver.should_receive(:execute).
+        with("SELECT * FROM bob WHERE ?", true).
+        and_return(RDO::Result.new([]))
+      stmt = driver.prepare("SELECT * FROM bob WHERE ?")
+      stmt.execute(true).should be_a_kind_of(RDO::Result)
+    end
+  end
+end

data/spec/rdo/emulated_statements_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe RDO::Driver, "emulated prepared statements" do
+  let(:driver) { RDO::DriverWithoutStatements.new }
+
+  describe "#command" do
+    it "returns the command string" do
+      driver.prepare("SELECT * FROM users").command.should == "SELECT * FROM users"
+    end
+  end
+
+  describe "#execute" do
+    let(:result) { stub(:result) }
+
+    it "delegates to the driver" do
+      driver.should_receive(:execute).with(
+        "SELECT * FROM users WHERE ? AND ?", 1, 2
+      ).and_return(result)
+      driver.prepare("SELECT * FROM users WHERE ? AND ?").execute(1, 2).should == result
+    end
+  end
+end

data/spec/rdo/result_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+describe RDO::Result do
+  it "is enumerable" do
+    RDO::Result.new([]).should be_a_kind_of(Enumerable)
+  end
+
+  describe "#each" do
+    let(:result) { RDO::Result.new([{id: 7}, {id: 42}]) }
+
+    it "enumerates all tuples" do
+      tuples = []
+      result.each{|row| tuples << row}
+      tuples.should == [{id: 7}, {id: 42}]
+    end
+
+    it "returns the result" do
+      result.each.should equal(result)
+    end
+  end
+
+  describe "#info" do
+    let(:result) { RDO::Result.new([], foo: "bar", zip: 42) }
+
+    it "returns all info passed to #initialize" do
+      result.info.should == {foo: "bar", zip: 42}
+    end
+  end
+
+  describe "#insert_id" do
+    context "when provided in the info" do
+      let(:result) { RDO::Result.new([], insert_id: 21) }
+
+      it "returns the ID from the info" do
+        result.insert_id.should == 21
+      end
+    end
+
+    context "when not provided in the info" do
+      context "and there are tuples" do
+        let(:result) { RDO::Result.new([{id: 6, name: "bob"}]) }
+
+        it "infers from the tuples" do
+          result.insert_id.should == 6
+        end
+      end
+
+      context "and there are no tuples" do
+        let(:result) { RDO::Result.new([]) }
+
+        it "returns nil" do
+          result.insert_id.should be_nil
+        end
+      end
+    end
+  end
+
+  describe "#affected_rows" do
+    context "when provided in the info" do
+      let(:result) { RDO::Result.new([], affected_rows: 3) }
+
+      it "returns the value from the info" do
+        result.affected_rows.should == 3
+      end
+    end
+
+    context "when not provided in the info" do
+      let(:result) { RDO::Result.new([]) }
+
+      it "returns nil" do
+        result.insert_id.should be_nil
+      end
+    end
+  end
+
+  describe "#count" do
+    context "when provided in the info" do
+      let(:result) { RDO::Result.new([{id: 7}, {id: 42}], count: 50) }
+
+      it "returns the count from the info" do
+        result.count.should == 50
+      end
+
+      context "with a block given" do
+        it "delegates to Enumerable" do
+          result.count{|row| row[:id] > 10}.should == 1
+        end
+      end
+    end
+
+    context "when not provided in the info" do
+      let(:result) { RDO::Result.new([{id: 7}, {id: 42}]) }
+
+      it "delegates to Enumerable" do
+        result.count.should == 2
+      end
+    end
+  end
+
+  describe "#first_value" do
+    context "when there are tuples" do
+      let(:result) { RDO::Result.new([{id: 6, name: "bob"}]) }
+
+      it "reads the first column in the first tuple" do
+        result.first_value.should == 6
+      end
+    end
+
+    context "when there are no tuples" do
+      let(:result) { RDO::Result.new([]) }
+
+      it "returns nil" do
+        result.first_value.should be_nil
+      end
+    end
+  end
+end

data/spec/rdo/statement_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe RDO::Statement do
+  let(:executor) { double(:executor) }
+  let(:stmt)     { RDO::Statement.new(executor) }
+
+  describe "#command" do
+    let(:command) { "SELECT * FROM users" }
+
+    it "delegates to the executor" do
+      executor.should_receive(:command).and_return(command)
+      stmt.command.should == command
+    end
+  end
+
+  describe "#execute" do
+    let(:result) { stub(:result) }
+
+    it "delegates to the executor" do
+      executor.should_receive(:execute).with(1, 2).and_return(result)
+      stmt.execute(1, 2).should == result
+    end
+  end
+end

data/spec/rdo/util_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+describe RDO::Util do
+  describe ".system_time_zone" do
+    it "returns the time zone of the local system" do
+      require "date"
+      RDO::Util.system_time_zone.should == DateTime.now.zone
+    end
+  end
+
+  describe ".float" do
+    context "with Infinity" do
+      it "returns Float::INFINITY" do
+        RDO::Util.float("Infinity").should == Float::INFINITY
+      end
+    end
+
+    context "with -Infinity" do
+      it "returns -Float::INFINITY" do
+        RDO::Util.float("-Infinity").should == -Float::INFINITY
+      end
+    end
+
+    context "with NaN" do
+      it "returns Float::NAN" do
+        RDO::Util.float("NaN").should be_nan
+      end
+    end
+
+    context "with a number" do
+      it "returns a Float" do
+        RDO::Util.float("1.2").should == 1.2
+      end
+    end
+
+    context "with an exponent" do
+      it "returns a Float" do
+        RDO::Util.float("1.1E-2").should == Float("1.1E-2")
+      end
+    end
+  end
+
+  describe "decimal" do
+    context "with NaN" do
+      it "returns NaN" do
+        RDO::Util.decimal("NaN").should be_nan
+      end
+    end
+
+    context "with a number" do
+      it "returns a BigDecimal" do
+        require "bigdecimal"
+        RDO::Util.decimal("1.2").should == BigDecimal("1.2")
+      end
+    end
+
+    context "with an exponent" do
+      it "returns a BigDecimal" do
+        require "bigdecimal"
+        RDO::Util.decimal("1E-2").should == BigDecimal("1E-2")
+      end
+    end
+  end
+
+  describe ".date" do
+    it "returns a Date" do
+      RDO::Util.date("2012-09-22").should == Date.new(2012, 9, 22)
+    end
+
+    context "with BC" do
+      it "returns a Date" do
+        RDO::Util.date("431-09-22 BC").should == Date.new(-430, 9, 22)
+      end
+    end
+  end
+
+  describe ".date_time_with_zone" do
+    it "returns a DateTime" do
+      require "date"
+      RDO::Util.date_time_with_zone("2012-09-22 10:04:32 +06:00").should ==
+        DateTime.parse("2012-09-22 10:04:32 +06:00")
+    end
+  end
+
+  describe ".date_time_without_zone" do
+    it "returns a DateTime in the system time zone" do
+      require "date"
+      RDO::Util.date_time_without_zone("2012-09-22 10:04:32").should ==
+        DateTime.parse("2012-09-22 10:04:32 #{DateTime.now.zone}")
+    end
+  end
+end