pod4 0.7.2 → 0.8.0

data/spec/mri/pg_interface_spec.rb

@@ -8,6 +8,9 @@ require_relative '../fixtures/database'
 class TestPgInterface < PgInterface
   set_table  :customer
   set_id_fld :id
+
+  # We open a lot of connections, unusually
+  def stop; close; end
 end
 
 class SchemaPgInterface < PgInterface
@@ -24,23 +27,33 @@ class BadPgInterface2 < PgInterface
   set_id_fld :id
 end
 
+class ProdPgInterface < PgInterface
+  set_table  :product
+  set_id_fld :code
+end
+
 
 describe TestPgInterface do
 
   def db_setup(connect)
     client = PG.connect(connect)
 
-    client.exec(%Q|drop table if exists customer;|)
-
     client.exec(%Q|
+      drop table if exists customer;
+      drop table if exists product;
+
       create table customer ( 
-        id        serial,
+        id        serial primary key,
         name      text,
         level     real      null,
         day       date      null,
         timestamp timestamp null,
         price     money     null,
-        qty       numeric   null );| )
+        qty       numeric   null );
+
+      create table product (
+        code text,
+        name text );| )
 
   ensure
     client.finish if client
@@ -52,6 +65,11 @@ describe TestPgInterface do
   end
 
 
+  def fill_product_data(ifce)
+    ifce.create( {code: "foo", name: "bar"} )
+  end
+
+
   before(:all) do
     @connect_hash = DB[:pg]
     db_setup(@connect_hash)
@@ -82,8 +100,16 @@ describe TestPgInterface do
 
 
   before do
-    # TRUNCATE TABLE also resets the identity counter
-    interface.execute(%Q|truncate table customer restart identity;|)
+    interface.execute(%Q|
+      truncate table customer restart identity;
+      truncate table product;|)
+
+  end
+
+
+  after do
+    # We open a lot of connections, unusually
+    interface.stop if interface
   end
 
 
@@ -91,6 +117,10 @@ describe TestPgInterface do
     TestPgInterface.new(@connect_hash)
   end
 
+  let(:prod_interface) do
+    ProdPgInterface.new(@connect_hash)
+  end
+
   #####
 
 
@@ -212,20 +242,29 @@ describe TestPgInterface do
       expect( interface.read(id).to_h ).to include ot.to_h
     end
 
-    it 'shouldnt have a problem with record values of nil' do
+    it 'shouldn\'t have a problem with record values of nil' do
       record = {name: 'Ranger', price: nil}
       expect{ interface.create(record) }.not_to raise_exception
       id = interface.create(record)
       expect( interface.read(id).to_h ).to include(record)
     end
 
-    it 'shouldnt have a problem with strings containing special characters' do
+    it 'shouldn\'t have a problem with strings containing special characters' do
       record = {name: %Q|T'Challa""|, price: nil}
       expect{ interface.create(record) }.not_to raise_exception
       id = interface.create(record)
       expect( interface.read(id).to_h ).to include(record)
     end
 
+    it 'shouldn\'t have a problem with non-integer keys' do
+      hash = {code: "foo", name: "bar"}
+      id = prod_interface.create( Octothorpe.new(hash) )
+
+      expect( id ).to eq "foo"
+      expect{ prod_interface.read("foo") }.not_to raise_exception
+      expect( prod_interface.read("foo").to_h ).to include hash
+    end
+
   end
   ##
 
@@ -284,6 +323,14 @@ describe TestPgInterface do
       expect( price ).to eq @data.first[:price]
     end
 
+    it 'shouldn\'t have a problem with non-integer keys' do
+      # this is a 100% overlap with the create test above...
+      fill_product_data(prod_interface)
+
+      expect{ prod_interface.read("foo") }.not_to raise_exception
+      expect( prod_interface.read("foo").to_h ).to include(code: "foo", name: "bar")
+    end
+
   end
   ##
 
@@ -337,8 +384,6 @@ describe TestPgInterface do
       record = {name: 'Booboo', price: 99.99}
       interface.update(id, record)
 
-      # It so happens that TinyTds returns money as BigDecimal --
-      # this is a really good thing, even though it screws with our test.
       expect( float_price( interface.read(id).to_h ) ).to include(record)
     end
 
@@ -354,26 +399,32 @@ describe TestPgInterface do
 
     end
 
-    it 'shouldnt have a problem with record values of nil' do
+    it 'shouldn\'t have a problem with record values of nil' do
       record = {name: 'Ranger', price: nil}
       expect{ interface.update(id, record) }.not_to raise_exception
       expect( interface.read(id).to_h ).to include(record)
     end
 
-    it 'shouldnt have a problem with strings containing special characters' do
+    it 'shouldn\'t have a problem with strings containing special characters' do
       record = {name: %Q|T'Challa""|, price: nil}
       expect{ interface.update(id, record) }.not_to raise_exception
       expect( interface.read(id).to_h ).to include(record)
     end
 
+    it 'shouldn\'t have a problem with non-integer keys' do
+      fill_product_data(prod_interface)
+      expect{ prod_interface.update("foo", name: "baz") }.not_to raise_error
+      expect( prod_interface.read("foo").to_h[:name] ).to eq "baz"
+    end
+
   end
   ##
 
 
   describe '#delete' do
 
-    def list_contains(id)
-      interface.list.find {|x| x[interface.id_fld] == id }
+    def list_contains(ifce, id)
+      ifce.list.find {|x| x[ifce.id_fld] == id }
     end
 
     let(:id) { interface.list.first[:id] }
@@ -386,9 +437,16 @@ describe TestPgInterface do
     end
 
     it 'makes the record at ID go away' do
-      expect( list_contains(id) ).to be_truthy
+      expect( list_contains(interface, id) ).to be_truthy
       interface.delete(id)
-      expect( list_contains(id) ).to be_falsy
+      expect( list_contains(interface, id) ).to be_falsy
+    end
+
+    it 'shouldn\'t have a problem with non-integer keys' do
+      fill_product_data(prod_interface)
+      expect( list_contains(prod_interface, "foo") ).to be_truthy
+      prod_interface.delete("foo")
+      expect( list_contains(prod_interface, "foo") ).to be_falsy
     end
 
   end
@@ -423,6 +481,34 @@ describe TestPgInterface do
   ##
 
 
+  describe '#executep' do
+
+    let(:sql) { 'delete from customer where cast(price as numeric) < %s and name = %s;' }
+
+    before { fill_data(interface) }
+
+    it 'requires an SQL string' do
+      expect{ interface.executep      }.to raise_exception ArgumentError
+      expect{ interface.executep(nil) }.to raise_exception ArgumentError
+      expect{ interface.executep(14)  }.to raise_exception ArgumentError
+    end
+
+    it 'raises some sort of Pod4 error if it runs into problems' do
+      expect{ interface.executep('delete from not_a_table where foo = %s', 12) }.
+        to raise_exception Pod4Error
+
+    end
+
+    it 'executes the string with the given parameters' do
+      expect{ interface.executep(sql, 12.0, 'Barney') }.not_to raise_exception
+      expect( interface.list.size ).to eq(@data.size - 1)
+      expect( interface.list.map{|r| r[:name] } ).not_to include 'Barney'
+    end
+
+  end
+  ##
+
+
   describe '#select' do
 
     before { fill_data(interface) }
@@ -462,5 +548,43 @@ describe TestPgInterface do
   ##
 
 
+  describe '#selectp' do
+
+    before { fill_data(interface) }
+
+    it 'requires an SQL string' do
+      expect{ interface.selectp            }.to raise_exception ArgumentError
+      expect{ interface.selectp(nil)       }.to raise_exception ArgumentError
+      expect{ interface.selectp(14)        }.to raise_exception ArgumentError
+    end
+
+    it 'raises some sort of Pod4 error if it runs into problems' do
+      expect{ interface.selectp('select * from not_a_table where thingy = %s', 12) }.
+        to raise_exception Pod4Error
+
+    end
+
+    it 'returns the result of the sql' do
+      sql = 'select name from customer where cast(price as numeric) < %s;'
+
+      expect{ interface.selectp(sql, 2.0) }.not_to raise_exception
+      expect( interface.selectp(sql, 2.0) ).to eq( [{name: 'Barney'}] )
+      expect( interface.selectp(sql, 0.0) ).to eq( [] )
+    end
+
+    it 'works if you pass a non-select' do
+      sql = 'delete from customer where cast(price as numeric) < %s;'
+      ret = interface.selectp(sql, 2.0)
+
+      expect( interface.list.size ).to eq(@data.size - 1)
+      expect( interface.list.map{|r| r[:name] } ).not_to include 'Barney'
+      expect( ret ).to eq( [] )
+    end
+
+
+  end
+  ##
+
+
 end
 

data/spec/mri/sequel_interface_spec.rb

@@ -27,6 +27,13 @@ class BadSequelInterface2 < SequelInterface
   set_id_fld :id
 end
 
+class ProdSequelInterface < SequelInterface
+  set_table  :product
+  set_id_fld :code
+end
+
+
+
 
 describe TestSequelInterface do
 
@@ -63,14 +70,18 @@ describe TestSequelInterface do
     data.each{|r| ifce.create(r) }
   end
 
+  def fill_product_data(ifce)
+    ifce.create( {code: "foo", name: "bar"} )
+  end
+
+
   # This is stolen almost verbatim from the Sequel Readme. We use an in-memory
   # sqlite database, and we assume that Sequel is sane and behaves broadly the
   # same for our limited purposes as it would when talking to TinyTDS or Pg.
-  # This may be an entirely unwarranted assumption. If so, we will have to
-  # change this. But in any case, we are not in the business of testing Sequel:
-  # just our interface to it.
+  # We test these elsewhere...
   let (:db) do
     db = Sequel.sqlite
+
     db.create_table :customer do
       primary_key :id
       String      :name
@@ -79,10 +90,17 @@ describe TestSequelInterface do
       Time        :timestamp
       BigDecimal  :price, :size=>[10.2] # Sequel doesn't support money
     end
+
+    db.create_table :product do
+      String :code, :primary_key => true
+      String :name
+    end
+
     db
   end
 
-  let(:interface) { TestSequelInterface.new(db) }
+  let(:interface)      { TestSequelInterface.new(db) }
+  let(:prod_interface) { ProdSequelInterface.new(db) }
 
   before do
     fill_data(interface)
@@ -108,8 +126,6 @@ describe TestSequelInterface do
     end
 
     let(:record)    { {name: 'Barney', price: 1.11} }
-    #let(:record_id) { 'Barney' }
-
   end
   ##
 
@@ -215,6 +231,7 @@ describe TestSequelInterface do
       # kinda impossible to seperate these two tests
       id = interface.create(hash)
 
+      expect( id ).not_to be_nil
       expect{ interface.read(id) }.not_to raise_exception
       expect( interface.read(id).to_h ).to include hash
     end
@@ -222,6 +239,7 @@ describe TestSequelInterface do
     it 'creates the record when given an Octothorpe' do
       id = interface.create(ot)
 
+      expect( id ).not_to be_nil
       expect{ interface.read(id) }.not_to raise_exception
       expect( interface.read(id).to_h ).to include ot.to_h
     end
@@ -231,20 +249,29 @@ describe TestSequelInterface do
       expect{ interface.create(name: :Booboo) }.not_to raise_exception
     end
 
-    it 'shouldnt have a problem with record values of nil' do
+    it 'shouldn\'t have a problem with record values of nil' do
       record = {name: 'Ranger', price: nil}
       expect{ interface.create(record) }.not_to raise_exception
       id = interface.create(record)
       expect( interface.read(id).to_h ).to include(record)
     end
 
-    it 'shouldnt have a problem with strings containing special characters' do
+    it 'shouldn\'t have a problem with strings containing special characters' do
       record = {name: "T'Challa[]", price: nil}
       expect{ interface.create(record) }.not_to raise_exception
       id = interface.create(record)
       expect( interface.read(id).to_h ).to include(record)
     end
 
+    it 'shouldn\'t have a problem with non-integer keys' do
+      hash = {code: "foo", name: "bar"}
+      id = prod_interface.create( Octothorpe.new(hash) )
+
+      expect( id ).to eq "foo"
+      expect{ prod_interface.read("foo") }.not_to raise_exception
+      expect( prod_interface.read("foo").to_h ).to include hash
+    end
+
   end
   ##
 
@@ -293,6 +320,14 @@ describe TestSequelInterface do
       expect( price ).to eq data.first[:price]
     end
 
+    it 'shouldn\'t have a problem with non-integer keys' do
+      # this is a 100% overlap with the create test above...
+      fill_product_data(prod_interface)
+
+      expect{ prod_interface.read("foo") }.not_to raise_exception
+      expect( prod_interface.read("foo").to_h ).to include(code: "foo", name: "bar")
+    end
+
   end
   ##
 
@@ -305,12 +340,31 @@ describe TestSequelInterface do
       expect{ interface.list(name: 'Barney') }.not_to raise_exception
     end
 
+=begin
     it 'returns an array of Octothorpes that match the records' do
       # convert each OT to a hash and remove the ID key
       arr = interface.list.map {|ot| x = ot.to_h; x.delete(:id); x }
 
       expect( arr ).to match_array data
     end
+=end
+
+    it 'returns an array of Octothorpes that match the records' do
+      arr = interface.list.map {|ot| x = ot.to_h}
+
+      expect( arr.size ).to eq(data.size)
+
+      data.each do |d|
+        r = arr.find{|x| x[:name] == d[:name] }
+        expect( r ).not_to be_nil
+        expect( r[:level]     ).to be_within(0.001).of( d[:level] )
+        expect( r[:day]       ).to eq d[:day]
+        expect( r[:timestamp] ).to eq d[:timestamp]
+        expect( r[:qty]       ).to eq d[:qty]
+      end
+
+    end
+
 
     it 'returns a subset of records based on the selection parameter' do
       expect( interface.list(name: 'Fred').size ).to eq 1
@@ -385,14 +439,20 @@ describe TestSequelInterface do
       expect( interface.read(id).to_h ).to include(record)
     end
 
+    it 'shouldn\'t have a problem with non-integer keys' do
+      fill_product_data(prod_interface)
+      expect{ prod_interface.update("foo", name: "baz") }.not_to raise_error
+      expect( prod_interface.read("foo").to_h[:name] ).to eq "baz"
+    end
+
   end
   ##
 
 
   describe '#delete' do
 
-    def list_contains(id)
-      interface.list.find {|x| x[interface.id_fld] == id }
+    def list_contains(ifce, id)
+      ifce.list.find {|x| x[ifce.id_fld] == id }
     end
 
     let(:id) { interface.list.first[:id] }
@@ -403,9 +463,16 @@ describe TestSequelInterface do
     end
 
     it 'makes the record at ID go away' do
-      expect( list_contains(id) ).to be_truthy
+      expect( list_contains(interface, id) ).to be_truthy
       interface.delete(id)
-      expect( list_contains(id) ).to be_falsy
+      expect( list_contains(interface, id) ).to be_falsy
+    end
+
+    it 'shouldn\'t have a problem with non-integer keys' do
+      fill_product_data(prod_interface)
+      expect( list_contains(prod_interface, "foo") ).to be_truthy
+      prod_interface.delete("foo")
+      expect( list_contains(prod_interface, "foo") ).to be_falsy
     end
 
   end
@@ -471,10 +538,76 @@ describe TestSequelInterface do
       expect( ret ).to eq( [] )
     end
 
-
   end
   ##
 
 
+  describe "#executep" do
+    # For the time being lets assume that Sequel does its job and the three modes we are calling
+    # actually work
+
+    let(:sql) { 'delete from customer where price < ?;' }
+
+    it 'requires an SQL string and a mode' do
+      expect{ interface.executep                 }.to raise_exception ArgumentError
+      expect{ interface.executep(nil)            }.to raise_exception ArgumentError
+      expect{ interface.executep(14, :update)    }.to raise_exception ArgumentError
+      expect{ interface.executep(14, :update, 2) }.to raise_exception ArgumentError
+    end
+
+    it 'requires the mode to be valid' do
+      expect{ interface.executep(sql, :foo, 2) }.to raise_exception ArgumentError
+    end
+
+    it 'raises some sort of Pod4 error if it runs into problems' do
+      expect{ interface.executep('delete from not_a_table where thingy = ?', :delete, 14) }.
+        to raise_exception Pod4Error
+
+    end
+
+    it 'executes the string' do
+      expect{ interface.executep(sql, :delete, 2.0) }.not_to raise_exception
+      expect( interface.list.size ).to eq(data.size - 1)
+      expect( interface.list.map{|r| r[:name] } ).not_to include 'Barney'
+    end
+
+  end
+
+
+  describe "#selectp" do
+
+    it 'requires an SQL string' do
+      expect{ interface.selectp      }.to raise_exception ArgumentError
+      expect{ interface.selectp(nil) }.to raise_exception ArgumentError
+      expect{ interface.selectp(14)  }.to raise_exception ArgumentError
+    end
+
+    it 'raises some sort of Pod4 error if it runs into problems' do
+      expect{ interface.selectp('select * from not_a_table where thingy = ?', 14) }.
+        to raise_exception Pod4Error
+
+    end
+
+    it 'returns the result of the sql' do
+      sql = 'select name from customer where price < ?;'
+
+      expect{ interface.selectp(sql, 2.0) }.not_to raise_exception
+      expect( interface.selectp(sql, 2.0) ).to eq( [{name: 'Barney'}] )
+      expect( interface.selectp(sql, 0.0) ).to eq( [] )
+    end
+
+    it 'works if you pass a non-select' do
+      # By which I mean: still executes the SQL; returns []
+      sql = 'delete from customer where price < ?;'
+      ret = interface.selectp(sql, 2.0)
+
+      expect( interface.list.size ).to eq(data.size - 1)
+      expect( interface.list.map{|r| r[:name] } ).not_to include 'Barney'
+      expect( ret ).to eq( [] )
+    end
+
+  end
+
+
 end