logstash-integration-jdbc 5.0.0.alpha1

data/spec/filters/jdbc/column_spec.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/filters/jdbc/column"
+
+describe LogStash::Filters::Jdbc::Column do
+  let(:invalid_messages) do
+    [
+      "The column options must be an array",
+      "The first column option is the name and must be a string",
+      "The second column option is the datatype and must be a string"
+    ]
+  end
+
+  context "various invalid non-array arguments" do
+    it "a nil does not validate" do
+      instance = described_class.new(nil)
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(invalid_messages.join(", "))
+    end
+
+    it "a string does not validate" do
+      instance = described_class.new("foo")
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(invalid_messages.values_at(0,2).join(", "))
+    end
+
+    it "a number does not validate" do
+      instance = described_class.new(42)
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(invalid_messages.join(", "))
+    end
+  end
+
+  context "various invalid array arguments" do
+    it "a single string element does not validate" do
+      instance = described_class.new(["foo"])
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(invalid_messages.last)
+    end
+    [ [], [1, 2] ].each do |arg|
+      it "do not validate" do
+        instance = described_class.new(arg)
+        expect(instance.valid?).to be_falsey
+        expect(instance.formatted_errors).to eq(invalid_messages.values_at(1,2).join(", "))
+      end
+    end
+    [ ["foo", 3], ["foo", nil] ].each do |arg|
+      it "do not validate" do
+        instance = described_class.new(arg)
+        expect(instance.valid?).to be_falsey
+        expect(instance.formatted_errors).to eq(invalid_messages.last)
+      end
+    end
+    [ [3, "foo"], [nil, "foo"] ].each do |arg|
+      it "do not validate" do
+        instance = described_class.new(arg)
+        expect(instance.valid?).to be_falsey
+        expect(instance.formatted_errors).to eq(invalid_messages[1])
+      end
+    end
+  end
+
+  context "a valid array argument" do
+    it "does validate" do
+      instance = described_class.new(["foo", "varchar2"])
+      expect(instance.valid?).to be_truthy
+      expect(instance.formatted_errors).to eq("")
+    end
+  end
+end

data/spec/filters/jdbc/db_object_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/filters/jdbc/db_object"
+
+describe LogStash::Filters::Jdbc::DbObject  do
+  context "various invalid non-hash arguments" do
+    it "a nil does not validate" do
+      instance = described_class.new(nil)
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq("DbObject options must be a Hash")
+    end
+
+    it "a string does not validate" do
+      instance = described_class.new("foo")
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq("DbObject options must be a Hash")
+    end
+
+    it "a number does not validate" do
+      instance = described_class.new(42)
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq("DbObject options must be a Hash")
+    end
+  end
+
+  context "various invalid hash arguments" do
+    let(:error_messages) do
+      [
+        "DbObject options must include a 'name' string",
+        "DbObject options for 'foo' must include a 'columns' array"
+      ]
+    end
+    "DbObject options must include a 'name' string, DbObject options for 'unnamed' must include a 'columns' array"
+    it "an empty hash does not validate" do
+      instance = described_class.new({})
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(error_messages.values_at(0,1).join(", ").gsub('foo', 'unnamed'))
+    end
+
+    it "a name key value only" do
+      instance = described_class.new({"name" => "foo"})
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(error_messages[1])
+    end
+
+    it "a name and bad columns" do
+      instance = described_class.new({"name" => "foo", "columns" => 42})
+      expect(instance.valid?).to be_falsey
+      expect(instance.formatted_errors).to eq(error_messages[1])
+    end
+
+    it "a name and bad columns - empty array" do
+      instance = described_class.new({"name" => "foo", "columns" => []})
+      expect(instance.valid?).to be_falsey
+      msg = "The columns array for 'foo' is not uniform, it should contain arrays of two strings only"
+      expect(instance.formatted_errors).to eq(msg)
+    end
+
+    it "a name and bad columns - irregular arrays" do
+      instance = described_class.new({"name" => "foo", "columns" => [["ip", "text"], ["name"], ["a", "b", "c"]]})
+      expect(instance.valid?).to be_falsey
+      msg = "The columns array for 'foo' is not uniform, it should contain arrays of two strings only"
+      expect(instance.formatted_errors).to eq(msg)
+    end
+
+    it "a name, good columns and bad index_column" do
+      instance = described_class.new({"name" => "foo_index", "index_columns" => ["bar"], "columns" => [["ip", "text"], ["name", "text"]]})
+      expect(instance.valid?).to be_falsey
+      msg = "The index_columns element: 'bar' must be a column defined in the columns array"
+      expect(instance.formatted_errors).to eq(msg)
+    end
+  end
+
+  context "a valid hash argument" do
+    it "does validate" do
+      instance = described_class.new({"name" => "foo", "index_columns" => ["ip"], "columns" => [["ip", "text"], ["name", "text"]]})
+      expect(instance.formatted_errors).to eq("")
+      expect(instance.valid?).to be_truthy
+    end
+  end
+end

data/spec/filters/jdbc/loader_spec.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/filters/jdbc/loader"
+
+describe LogStash::Filters::Jdbc::Loader do
+  let(:local_table) { "servers" }
+  let(:options) do
+    {
+      "jdbc_driver_class" => "org.postgresql.Driver",
+      "jdbc_connection_string" => "jdbc:postgres://user:password@remotedb/infra",
+      "query" => "select ip, name, location from INTERNAL.SERVERS",
+      "jdbc_user" => "bob",
+      "jdbc_password" => "letmein",
+      "max_rows" => 2000,
+      "local_table" => local_table
+    }
+  end
+  subject { described_class.new(options) }
+
+  context "when correct options are given" do
+    it "validation succeeds" do
+      expect(subject.valid?).to be_truthy
+      expect(subject.formatted_errors).to eq("")
+    end
+  end
+
+  context "when incorrect options are given" do
+    let(:options) do
+      {
+        "jdbc_driver_class" => 42,
+        "jdbc_connection_string" => 42,
+        "max_rows" => ["2000"]
+      }
+    end
+
+    it "validation fails" do
+      expect(subject.valid?).to be_falsey
+      expect(subject.formatted_errors).to eq("The options must include a 'local_table' string, The options for '' must include a 'query' string, The 'max_rows' option for '' must be an integer, The 'jdbc_driver_class' option for '' must be a string, The 'jdbc_connection_string' option for '' must be a string")
+    end
+  end
+
+  context "attr_reader methods" do
+    it "#table" do
+      expect(subject.table).to eq(:servers)
+    end
+
+    it "#query" do
+      expect(subject.query).to eq("select ip, name, location from INTERNAL.SERVERS")
+    end
+
+    it "#max_rows" do
+      expect(subject.max_rows).to eq(2000)
+    end
+
+    it "#connection_string" do
+      expect(subject.connection_string).to eq("jdbc:postgres://user:password@remotedb/infra")
+    end
+
+    it "#driver_class" do
+      expect(subject.driver_class).to eq("org.postgresql.Driver")
+    end
+
+    it "#driver_library" do
+      expect(subject.driver_library).to be_nil
+    end
+
+    it "#user" do
+      expect(subject.user).to eq("bob")
+    end
+
+    it "#password" do
+      expect(subject.password.value).to eq("letmein")
+    end
+  end
+
+
+end

data/spec/filters/jdbc/lookup_processor_spec.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/filters/jdbc/lookup_processor"
+
+module LogStash module Filters module Jdbc
+  describe LookupProcessor do
+    describe "class method find_validation_errors" do
+      context "when supplied with an invalid arg" do
+        it "nil as arg, fails validation" do
+          result = described_class.find_validation_errors(nil)
+          expect(result).to eq("The options must be an Array")
+        end
+
+        it "hash as arg, fails validation" do
+          result = described_class.find_validation_errors({})
+          expect(result).to eq("The options must be an Array")
+        end
+
+        it "array of lookup hash without query key as arg, fails validation" do
+          lookup_hash = {
+            "parameters" => {"ip" => "%%{[ip]}"},
+            "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The options for 'lookup-1' must include a 'query' string")
+        end
+
+        it "array of lookup hash with bad parameters value as arg, fails validation" do
+          lookup_hash = {
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => %w(ip %%{[ip]}),
+            "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The 'parameters' option for 'lookup-1' must be a Hash")
+        end
+
+        it "array of lookup hash with bad parameters value as arg and no target, fails validation" do
+          lookup_hash = {
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => %w(ip %%{[ip]})
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The 'parameters' option for 'lookup-1' must be a Hash")
+        end
+
+        it "array of lookup hashes with invalid settings, fails validation with messages from each lookup" do
+          lookup_hash1 = {
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => ["ip", "%%{[ip]}"],
+            "target" => "server"
+          }
+          lookup_hash2 = {
+            "parameters" => {"id" => "%%{[id]}"},
+            "default_hash" => {},
+            "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash1, lookup_hash2])
+          expected = ["The 'parameters' option for 'lookup-1' must be a Hash"]
+          expected << "The options for 'lookup-2' must include a 'query' string"
+          expected << "Target setting must be different across all lookups, 'lookup-1', 'lookup-2' have the same target field setting"
+          expect(result).to eq(expected.join("; "))
+        end
+
+        it "array of lookup hashes with same id, fails validation with messages from each lookup" do
+          lookup_hash1 = {
+            "id" => "L1",
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => ["ip", "%%{[ip]}"],
+          }
+          lookup_hash2 = {
+            "id" => "L1",
+            "parameters" => {"id" => "%%{[id]}"},
+            "default_hash" => {},
+          }
+          result = described_class.find_validation_errors([lookup_hash1, lookup_hash2])
+          expected = ["The 'parameters' option for 'L1' must be a Hash"]
+          expected << "The options for 'L1' must include a 'query' string"
+          expected << "Id setting must be different across all lookups, 'L1' is specified multiple times"
+          expect(result).to eq(expected.join("; "))
+        end
+
+        it "array of valid lookup hashes as arg with the same target, fails validation" do
+          lookup_hash1 = {
+            "id" => "L1",
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => {"ip" => "%%{[ip]}"},
+            "target" => "server"
+          }
+          lookup_hash2 = {
+            "id" => "L2",
+            "query" => "select * from users WHERE id LIKE :id",
+            "parameters" => {"id" => "%%{[id]}"},
+            "target" => "server"
+          }
+          lookup_hash3 = {
+            "id" => "L3",
+            "query" => "select * from table1 WHERE ip LIKE :ip",
+            "parameters" => {"ip" => "%%{[ip]}"},
+            "target" => "somefield"
+          }
+          lookup_hash4 = {
+            "id" => "L4",
+            "query" => "select * from table2 WHERE id LIKE :id",
+            "parameters" => {"id" => "%%{[id]}"},
+            "target" => "somefield"
+          }
+          result = described_class.find_validation_errors([lookup_hash1, lookup_hash2, lookup_hash3, lookup_hash4])
+          expect(result).to eq("Target setting must be different across all lookups, 'L1', 'L2' have the same target field setting, 'L3', 'L4' have the same target field setting")
+        end
+      end
+
+      context "when supplied with a valid arg" do
+        it "empty array as arg, passes validation" do
+          result = described_class.find_validation_errors([])
+          expect(result).to eq(nil)
+        end
+
+        it "array of valid lookup hash as arg, passes validation" do
+          lookup_hash = {
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => {"ip" => "%%{[ip]}"},
+            "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq(nil)
+        end
+      end
+    end
+  end
+end end end
+

data/spec/filters/jdbc/lookup_spec.rb

@@ -0,0 +1,253 @@
+# encoding: utf-8
+require_relative "../env_helper"
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/filters/jdbc/lookup"
+
+module LogStash module Filters module Jdbc
+  describe Lookup do
+    describe "class method find_validation_errors" do
+      context "when supplied with an invalid arg" do
+        it "nil as arg, fails validation" do
+          result = described_class.find_validation_errors(nil)
+          expect(result).to eq("The options must be an Array")
+        end
+
+        it "hash as arg, fails validation" do
+          result = described_class.find_validation_errors({})
+          expect(result).to eq("The options must be an Array")
+        end
+
+        it "array of lookup hash without query key as arg, fails validation" do
+          lookup_hash = {
+          "parameters" => {"ip" => "%%{[ip]}"},
+          "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The options for 'lookup-1' must include a 'query' string")
+        end
+
+        it "array of lookup hash with bad parameters value as arg, fails validation" do
+          lookup_hash = {
+          "query" => "select * from servers WHERE ip LIKE :ip",
+          "parameters" => %w(ip %%{[ip]}),
+          "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The 'parameters' option for 'lookup-1' must be a Hash")
+        end
+
+        it "array of lookup hash with bad parameters value as arg and no target, fails validation" do
+          lookup_hash = {
+          "query" => "select * from servers WHERE ip LIKE :ip",
+          "parameters" => %w(ip %%{[ip]})
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The 'parameters' option for 'lookup-1' must be a Hash")
+        end
+
+        it "parameters and prepared_parameters are defined at same time" do
+          lookup_hash = {
+          "query" => "SELECT * FROM table WHERE ip=?",
+          "parameters" => {"ip" => "%%{[ip]}"},
+          "prepared_parameters" => ["%%{[ip]}"],
+          "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("Can't specify 'parameters' and 'prepared_parameters' in the same lookup")
+        end
+
+        it "prepared_parameters count doesn't match the number of '?' in the query" do
+          lookup_hash = {
+          "query" => "SELECT * FROM table WHERE ip=? AND host=?",
+          "prepared_parameters" => ["%%{[ip]}"],
+          "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq("The 'prepared_parameters' option for 'lookup-1' doesn't match count with query's placeholder")
+        end
+      end
+
+      context "when supplied with a valid arg" do
+        it "empty array as arg, passes validation" do
+          result = described_class.find_validation_errors([])
+          expect(result).to eq(nil)
+        end
+
+        it "array of valid lookup hash as arg, passes validation" do
+          lookup_hash = {
+            "query" => "select * from servers WHERE ip LIKE :ip",
+            "parameters" => {"ip" => "%%{[ip]}"},
+            "target" => "server"
+          }
+          result = described_class.find_validation_errors([lookup_hash])
+          expect(result).to eq(nil)
+        end
+      end
+    end
+
+    describe "abnormal operations" do
+      let(:local_db) { double("local_db") }
+      let(:lookup_hash) do
+        {
+        "query" => "select * from servers WHERE ip LIKE :ip",
+        "parameters" => {"ip" => "%%{[ip]}"},
+        "target" => "server",
+        "tag_on_failure" => ["_jdbcstaticfailure_server"]
+        }
+      end
+      let(:event) { LogStash::Event.new()}
+      let(:records) { [{"name" => "ldn-1-23", "rack" => "2:1:6"}] }
+
+      subject(:lookup) { described_class.new(lookup_hash, {}, "lookup-1") }
+
+      before(:each) do
+        allow(local_db).to receive(:fetch).once.and_return(records)
+      end
+
+      it "should not enhance an event and it should tag" do
+        subject.enhance(local_db, event)
+        expect(event.get("tags")).to eq(["_jdbcstaticfailure_server"])
+        expect(event.get("server")).to be_nil
+      end
+    end
+
+    describe "normal operations" do
+      let(:local_db) { double("local_db") }
+      let(:lookup_hash) do
+        {
+          "query" => "select * from servers WHERE ip LIKE :ip",
+          "parameters" => {"ip" => "%%{[ip]}"},
+          "target" => "server",
+          "tag_on_failure" => ["_jdbcstaticfailure_server"]
+        }
+      end
+      let(:event) { LogStash::Event.new()}
+      let(:records) { [{"name" => "ldn-1-23", "rack" => "2:1:6"}] }
+
+      subject(:lookup) { described_class.new(lookup_hash, {}, "lookup-1") }
+
+      before(:each) do
+        allow(local_db).to receive(:fetch).once.and_return(records)
+      end
+
+      it "should be valid" do
+        expect(subject.valid?).to be_truthy
+      end
+
+      it "should have no formatted_errors" do
+        expect(subject.formatted_errors).to eq("")
+      end
+
+      it "should enhance an event" do
+        event.set("ip", "20.20")
+        subject.enhance(local_db, event)
+        expect(event.get("tags")).to be_nil
+        expect(event.get("server")).to eq(records)
+      end
+    end
+
+    describe "lookup operations with prepared statement" do
+      let(:local_db) { double("local_db") }
+      let(:lookup_hash) do
+        {
+          "query" => "select * from servers WHERE ip LIKE ?",
+          "prepared_parameters" => ["%%{[ip]}"],
+          "target" => "server",
+          "tag_on_failure" => ["_jdbcstaticfailure_server"]
+        }
+      end
+      let(:event) { LogStash::Event.new()}
+      let(:records) { [{"name" => "ldn-1-23", "rack" => "2:1:6"}] }
+      let(:prepared_statement) { double("prepared_statement")}
+
+      subject(:lookup) { described_class.new(lookup_hash, {}, "lookup-1") }
+
+      before(:each) do
+        allow(local_db).to receive(:prepare).once.and_return(prepared_statement)
+        allow(prepared_statement).to receive(:call).once.and_return(records)
+      end
+
+      it "should be valid" do
+        expect(subject.valid?).to be_truthy
+      end
+
+      it "should have no formatted_errors" do
+        expect(subject.formatted_errors).to eq("")
+      end
+
+      it "should enhance an event" do
+        event.set("ip", "20.20")
+        subject.prepare(local_db)
+        subject.enhance(local_db, event)
+        expect(event.get("tags")).to be_nil
+        expect(event.get("server")).to eq(records)
+      end
+    end
+
+    describe "lookup operations with prepared statement multiple parameters" do
+      let(:local_db) { double("local_db") }
+      let(:lookup_hash) do
+        {
+          "query" => "select * from servers WHERE ip LIKE ? AND os LIKE ?",
+          "prepared_parameters" => ["%%{[ip]}", "os"],
+          "target" => "server",
+          "tag_on_failure" => ["_jdbcstaticfailure_server"]
+        }
+      end
+      let(:event) { LogStash::Event.new()}
+      let(:records) { [{"name" => "ldn-1-23", "rack" => "2:1:6"}] }
+      let(:prepared_statement) { double("prepared_statement")}
+
+      subject(:lookup) { described_class.new(lookup_hash, {}, "lookup-1") }
+
+      before(:each) do
+        allow(local_db).to receive(:prepare).once.and_return(prepared_statement)
+        allow(prepared_statement).to receive(:call).once.and_return(records)
+      end
+
+      it "should be valid" do
+        expect(subject.valid?).to be_truthy
+      end
+
+      it "should have no formatted_errors" do
+        expect(subject.formatted_errors).to eq("")
+      end
+
+      it "should enhance an event" do
+        event.set("ip", "20.20")
+        event.set("os", "MacOS")
+        subject.prepare(local_db)
+        subject.enhance(local_db, event)
+        expect(event.get("tags")).to be_nil
+        expect(event.get("server")).to eq(records)
+      end
+    end
+
+    describe "lookup operations with badly configured prepared statement" do
+      let(:local_db) { double("local_db") }
+      let(:lookup_hash) do
+        {
+          "query" => "select * from servers WHERE ip LIKE ? AND os LIKE ?",
+          "prepared_parameters" => ["%%{[ip]}"],
+          "target" => "server",
+          "tag_on_failure" => ["_jdbcstaticfailure_server"]
+        }
+      end
+      let(:event) { LogStash::Event.new()}
+      let(:records) { [{"name" => "ldn-1-23", "rack" => "2:1:6"}] }
+      let(:prepared_statement) { double("prepared_statement")}
+
+      subject(:lookup) { described_class.new(lookup_hash, {}, "lookup-1") }
+
+      before(:each) do
+        allow(local_db).to receive(:prepare).once.and_return(prepared_statement)
+        allow(prepared_statement).to receive(:call).once.and_return(records)
+      end
+
+      it "must not be valid" do
+        expect(subject.valid?).to be_falsey
+      end
+    end
+  end
+end end end
+

data/spec/filters/jdbc/read_only_database_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require "logstash/devutils/rspec/spec_helper"
+require "logstash/util/password"
+require "logstash/filters/jdbc/read_only_database"
+
+module LogStash module Filters module Jdbc
+  describe ReadOnlyDatabase do
+    let(:db) { Sequel.connect('mock://mydb') }
+    let(:connection_string) { "mock://mydb" }
+    let(:driver_class) { "org.apache.derby.jdbc.EmbeddedDriver" }
+    let(:driver_library) { nil }
+    subject(:read_only_db) { described_class.create(connection_string, driver_class, driver_library) }
+
+    describe "basic operations" do
+      describe "initializing" do
+        it "tests the connection with defaults" do
+          expect(Sequel::JDBC).to receive(:load_driver).once.with(driver_class)
+          expect(Sequel).to receive(:connect).once.with(connection_string, {:test => true})
+          expect(read_only_db.empty_record_set).to eq([])
+        end
+
+        it "tests the connection with fully specified arguments" do
+          connection_str = "a connection string"
+          user = "a user"
+          password = Util::Password.new("secret")
+          expect(Sequel::JDBC).to receive(:load_driver).once.with("a driver class")
+          expect(Sequel).to receive(:connect).once.with(connection_str, {:user => user, :password =>  password.value, :test => true}).and_return(db)
+          described_class.create(connection_str, "a driver class", nil, user, password)
+        end
+
+        it "connects with defaults" do
+          expect(Sequel::JDBC).to receive(:load_driver).once.with(driver_class)
+          expect(Sequel).to receive(:connect).once.with(connection_string, {:test => true}).and_return(db)
+          expect(Sequel).to receive(:connect).once.with(connection_string, {}).and_return(db)
+          expect(read_only_db.connected?).to be_falsey
+          read_only_db.connect("a caller specific error message")
+          expect(read_only_db.connected?).to be_truthy
+        end
+      end
+
+      describe "methods" do
+        let(:dataset) { double("Sequel::Dataset") }
+
+        before(:each) do
+          allow(Sequel::JDBC).to receive(:load_driver)
+          allow(Sequel).to receive(:connect).thrice.and_return(db)
+          allow(db).to receive(:[]).and_return(dataset)
+          read_only_db.connect("a caller specific error message")
+        end
+
+        after(:each) do
+          read_only_db.disconnect("a caller specific error message")
+        end
+
+        it "the count method gets a count from the dataset" do
+          expect(dataset).to receive(:count).and_return(0)
+          read_only_db.count("select * from table")
+        end
+
+        it "the query method gets all records from the dataset" do
+          expect(dataset).to receive(:all).and_return(read_only_db.empty_record_set)
+          read_only_db.query("select * from table")
+        end
+      end
+    end
+  end
+end end end