pod4 0.10.6 → 1.0.0

data/spec/common/connection_pool_spec.rb

@@ -0,0 +1,246 @@
+require "pod4/connection_pool"
+
+
+describe Pod4::ConnectionPool do
+
+  let(:ifce_class) do
+    Class.new Pod4::Interface do
+      def initialize;                  end
+      def close_connection;            end
+      def new_connection(opts); @conn; end
+
+      def set_conn(c); @conn = c; end
+    end
+  end
+
+
+  describe "#new" do
+     
+    it "accepts some options and stores them as attributes" do
+      c = ConnectionPool.new(interface: ifce_class, max_clients: 4, max_wait: 4_000)
+
+      expect( c.max_clients ).to eq 4
+      expect( c.max_wait    ).to eq 4_000
+    end
+
+    it "falls back to reasonable defaults" do
+      c = ConnectionPool.new(interface: ifce_class)
+
+      expect( c.max_clients ).to eq 10
+      expect( c.max_wait    ).to eq nil
+    end
+
+  end # of #new
+
+
+  describe "#client" do
+     
+    context "when there is a client in the pool for this thread" do
+      before(:each) do
+        @connection = ConnectionPool.new(interface: ifce_class)
+        @connection.data_layer_options = "meh"
+        @interface = ifce_class.new
+        @interface.set_conn "bar"
+
+        # First call to client for a thread should assign a client to it
+        @connection.client(@interface)
+        expect( @connection._pool.size            ).to eq 1
+        expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+      end
+       
+      it "returns that client" do
+        expect( @interface ).not_to receive(:new_connection)
+        expect( @connection.client(@interface) ).to eq "bar"
+      end
+    end # of when there is a client in the pool for this thread
+
+    context "when there is no client for this thread and a free one in the pool" do
+      before(:each) do
+        @connection = ConnectionPool.new(interface: ifce_class)
+        @connection.data_layer_options = "meh"
+        @interface = ifce_class.new
+        @interface.set_conn "foo"
+
+        # Call client to assign a client to the thread; then call close to release it. We end up
+        # with a client in the pool which is assigned to no thread.
+        @connection.client(@interface)
+        @connection.close(@interface)
+        expect( @connection._pool.size            ).to eq 1
+        expect( @connection._pool.first.thread_id ).to be_nil
+      end
+       
+      it "returns the free one" do
+        expect( @interface ).not_to receive(:new_connection).and_call_original
+        expect( @connection.client(@interface) ).to eq "foo"
+      end
+
+      it "assigns the client to this thread id" do
+        @connection.client(@interface)
+        expect( @connection._pool.size ).to eq 1
+        expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+      end
+    end # of when there is no client for this thread and a free one
+
+    context "when max_clients == nil, there is no client for this thread and none free" do
+      before(:each) do
+        @connection = ConnectionPool.new(interface: ifce_class)
+        @connection.data_layer_options = "meh"
+        @interface = ifce_class.new
+        @interface.set_conn "foo"
+
+        # The simplest case for this scenario is an empty pool
+      end
+
+      it "asks the interface to give it a new client and returns that" do
+        expect( @interface ).to receive(:new_connection).with("meh").and_call_original
+        expect( @connection.client(@interface) ).to eq "foo"
+      end
+
+      it "stores the new client from the interface in the pool against the thread" do
+        @connection.client(@interface)
+        expect( @connection._pool.size ).to eq 1
+        expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+      end
+    end # of when max_clients == nil, there is no client for this thread and none free
+
+    context "when max_clients != nil, there is no client for this thread and none free" do
+
+      context "when we're not at the maximum" do
+        before(:each) do
+          @connection = ConnectionPool.new(interface: ifce_class, max_clients: 1)
+          @connection.data_layer_options = "meh"
+          @interface = ifce_class.new
+          @interface.set_conn "baz"
+
+          #this is an empty pool again
+        end
+
+        it "asks the interface to give it a new client and returns that" do
+          expect( @interface ).to receive(:new_connection).with("meh").and_call_original
+          expect( @connection.client(@interface) ).to eq "baz"
+        end
+
+        it "stores the new client from the interface in the pool against the thread" do
+          @connection.client(@interface)
+          expect( @connection._pool.size ).to eq 1
+          expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+        end
+      end
+
+      context "when we reach the maximum" do
+        before(:each) do
+          @connection = ConnectionPool.new(interface: ifce_class, max_clients: 1)
+          @connection.data_layer_options = "meh"
+          @interface = ifce_class.new
+          @interface.set_conn "boz"
+
+          # assign our 1 client in the pool to a different thread
+          @thread = Thread.new do 
+            @connection.client(@interface) 
+            Thread.stop # pause the thread here until something external restarts it
+            sleep 1
+            @connection.close(@interface) 
+          end
+          sleep 0.1 until @thread.stop?
+
+          expect( @connection._pool.size ).to eq 1
+          expect( @connection._pool.first.thread_id ).not_to be_nil
+          expect( @connection._pool.first.thread_id ).not_to eq Thread.current.object_id
+        end
+
+        after(:each) { @thread&.kill }
+
+        it "blocks until a thread is free" do
+          # This is hard to test! We can do it but we have to make the horrible assumption that we
+          # are using the Ruby `loop` keyword, then stub a loop method to override it.
+          expect( @connection ).to receive(:loop).and_yield.and_yield.and_yield
+
+          @connection.client(@interface)
+        end
+
+        it "once a client is released it uses that" do
+          @thread.run # free pool in 1 sec (we want to be already running #client when it frees)
+          expect( @connection.client(@interface) ).to eq "boz" # ...eventually
+          expect( @connection._pool.size ).to eq 1
+          expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+        end
+      end # of when we reach the maximum
+
+      context "when we reach the maximum, max_wait is set and the time is up" do
+        before(:each) do
+          @connection = ConnectionPool.new(interface: ifce_class, max_clients: 2, max_wait: 1)
+          @connection.data_layer_options = "meh"
+          @interface = ifce_class.new
+          @interface.set_conn "foo"
+
+          # assign our 2 clients in the pool to a different thread
+          @threads = []
+          2.times do
+            @threads << Thread.new { @connection.client(@interface); Thread.stop }
+          end
+          sleep 0.1 until @threads.all?{|t| t.stop? }
+
+          expect( @connection._pool.size ).to eq 2
+          @threads.each do |t|
+            expect( t ).not_to be_nil
+            expect( t ).not_to eq Thread.current.object_id
+          end
+        end
+
+        after(:each) { @threads.each{|t| t.kill} }
+
+        it "raises a PoolTimeout" do
+          expect{ @connection.client(@interface) }.to raise_error Pod4::PoolTimeout
+        end
+      end # of when we reach the maximum, max_wait is set and the time is up
+
+    end # of when max_clients != nil, there is no client for this thread and none free
+    
+  end # of #client
+
+
+  describe "#close" do
+    before(:each) do
+      @connection = ConnectionPool.new(interface: ifce_class)
+      @connection.data_layer_options = "meh"
+      @interface = ifce_class.new
+      @interface.set_conn "brep"
+
+      @connection.client(@interface)
+      expect( @connection._pool.size ).to eq 1
+      expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+    end
+     
+    it "de-assigns the client for this thread from the thread" do
+      @connection.close(@interface)
+      expect( @connection._pool.size ).to eq 1
+      expect( @connection._pool.first.thread_id ).to be_nil
+    end
+
+  end # of #close
+
+
+  describe "#drop" do
+    before(:each) do
+      @connection = ConnectionPool.new(interface: ifce_class)
+      @connection.data_layer_options = "meh"
+      @interface = ifce_class.new
+      @interface.set_conn "flong"
+
+      @connection.client(@interface)
+      expect( @connection._pool.size ).to eq 1
+      expect( @connection._pool.first.thread_id ).to eq Thread.current.object_id
+    end
+     
+    it "removes the client object from the pool entirely" do
+      @connection.drop(@interface)
+      expect( @connection._pool.size ).to eq 0
+    end
+    
+  end # of #drop
+  
+  
+
+
+end
+

data/spec/common/connection_spec.rb

@@ -0,0 +1,129 @@
+require 'pod4/connection'
+require 'pod4/null_interface'
+
+
+##
+# I can't make these anonymous classes in an Rspec `let`, because the name of the interface class is
+# passed to the Connection object when it is initialised.
+##
+
+class ConnectionTestingI < Interface
+  def initialize;                         end
+  def close_connection;                   end
+  def new_connection(args); {conn: args}; end
+end
+
+class ConnectionTestingIBad < Interface
+  def initialize;           end
+  def close_connection;     end
+  def new_connection(args); end
+end
+
+
+describe Pod4::Connection do
+
+  let(:interface) { ConnectionTestingI.new }
+  let(:conn)      { Pod4::Connection.new(interface: ConnectionTestingI) }
+
+
+  describe "#new" do
+
+    it "takes a hash" do
+      expect{ Pod4::Connection.new       }.to raise_error ArgumentError
+      expect{ Pod4::Connection.new(:foo) }.to raise_error ArgumentError
+    end
+
+    it "needs :interface, a Pod4::Interface class" do
+      expect{ Pod4::Connection.new(interface: "foo") }.to raise_error ArgumentError
+      expect{ Pod4::Connection.new(interface: Array) }.to raise_error ArgumentError
+      expect{ Pod4::Connection.new(interface: ConnectionTestingI) }.not_to raise_error
+      
+      expect( conn.interface_class ).to eq ConnectionTestingI
+    end
+
+  end # of #new
+
+
+  describe "#data_layer_options" do
+
+    it "stores an arbitrary object" do
+      expect( conn.data_layer_options ).to be_nil
+
+      conn.data_layer_options = {one: 2, three: 4}
+
+      expect( conn.data_layer_options ).to eq(one: 2, three: 4)
+    end
+
+  end # of #data_layer_options
+
+
+  describe "#close" do
+
+    it "raises ArgumentError if given an interface that wasn't the one you passed in #new" do
+      i = ConnectionTestingIBad.new
+      expect{ conn.close(i) }.to raise_error ArgumentError
+    end
+
+    it "calls close on the interface" do
+      expect(interface).to receive(:close_connection)
+
+      conn.close(interface)
+    end
+
+    it "resets the stored client" do
+      conn.close(interface)
+
+      # Now the stored client should be unset, so a further call to #client should ask the
+      # interface for one
+      expect(interface).to receive(:new_connection)
+
+      conn.client(interface)
+    end
+
+  end # of #close
+
+
+  describe "#client" do
+
+    it "takes an interface object" do
+      expect{ conn.client     }.to raise_exception ArgumentError
+      expect{ conn.client(14) }.to raise_exception ArgumentError
+
+      expect{ conn.client(interface) }.not_to raise_exception
+    end
+
+    it "raises ArgumentError if given an interface that wasn't the one you passed in #new" do
+      i = ConnectionTestingIBad.new
+      expect{ conn.client(i) }.to raise_error ArgumentError
+    end
+
+    context "when it has no connection" do
+
+      it "calls new_connection on the interface" do
+        expect(interface).to receive(:new_connection).with("bar").and_call_original
+
+        conn.data_layer_options = "bar"
+
+        expect( conn.client(interface) ).to eq(conn: "bar")
+      end
+
+    end
+
+    context "when it has a connection" do
+
+      it "returns what it has" do
+        # set things up like before so we have an existing connection
+        conn.data_layer_options = "foo"
+        conn.client(interface) 
+
+        expect(interface).not_to receive(:new_connection)
+
+        expect( conn.client(interface) ).to eq(conn: "foo")
+      end
+
+    end
+
+  end # of #client
+
+
+end

data/spec/common/model_ai_missing_id_spec.rb

@@ -0,0 +1,256 @@
+require "octothorpe"
+
+require "pod4/model"
+require "pod4/null_interface"
+
+
+##
+# This test covers a model with an autoincrementing ID but where the ID field is not named as an
+# attribute. Pre-1.0 you _had_ to do it this way. No reason why it would not be an option going
+# forward.
+#
+describe "(Autoincrementing Model with No ID Attribute)" do
+
+  let(:customer_model_class) do
+    Class.new Pod4::Model do
+      attr_columns :name, :groups, :price
+      set_interface NullInterface.new(:id, :name, :price, :groups, 
+        [ {id: 1, name: "Gomez",     price: 1.23, groups: "trains"       },
+          {id: 2, name: "Morticia",  price: 2.34, groups: "spanish"      },
+          {id: 3, name: "Wednesday", price: 3.45, groups: "school"       },
+          {id: 4, name: "Pugsley",   price: 4.56, groups: "trains,school"} ] )
+
+    end
+  end
+
+  let(:records) do
+    [ {id: 1, name: "Gomez",     price: 1.23, groups: "trains"       },
+      {id: 2, name: "Morticia",  price: 2.34, groups: "spanish"      },
+      {id: 3, name: "Wednesday", price: 3.45, groups: "school"       },
+      {id: 4, name: "Pugsley",   price: 4.56, groups: "trains,school"} ]
+
+  end
+
+  let(:records_as_ot)  { records.map{|r| Octothorpe.new(r) } }
+
+  # model is just a plain newly created object that you can call read on.
+  # model2 and model3 are in an identical state - they have been filled with a
+  # read(). We have two so that we can RSpec "allow" on one and not the other.
+
+  let(:model) { customer_model_class.new(2) }
+
+  let(:model2) do
+    m = customer_model_class.new(3)
+
+    allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[2]) )
+    m.read.or_die
+  end
+
+  let(:model3) do
+    m = customer_model_class.new(4)
+
+    allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[3]) )
+    m.read.or_die
+  end
+
+
+  describe "Model.list" do
+    let(:list1) { customer_model_class.list }
+
+    it "returns an array of customer_model_class records" do
+      expect( list1 ).to be_a_kind_of Array
+      expect( list1 ).to all(be_a_kind_of customer_model_class)
+    end
+
+    it "returns the data from the interface" do
+      expect( list1.size ).to eq records.size
+      expect( list1.map(&:to_ot).map(&:to_h) ).to match_array(records)
+    end
+
+  end # of Model.list
+
+
+  describe "#columns" do
+
+    it "returns the attr_columns list from the class definition" do
+      expect( customer_model_class.new.columns ).
+        to match_array( [:name,:price,:groups] )
+
+    end
+
+  end # of #columns
+
+
+  describe "#set" do
+    let (:ot) { records_as_ot[3] }
+
+    it "takes an Octothorpe or a Hash" do
+      expect{ model.set       }.to raise_exception ArgumentError
+      expect{ model.set(nil)  }.to raise_exception ArgumentError
+      expect{ model.set(:foo) }.to raise_exception ArgumentError
+
+      expect{ model.set(ot) }.not_to raise_exception 
+    end
+
+    it "returns self" do
+      expect( model.set(ot) ).to eq model
+    end
+
+    it "sets the attribute columns from the hash" do
+      model.set(ot)
+
+      expect( model.name  ).to eq ot.>>.name
+      expect( model.price ).to eq ot.>>.price
+    end
+    
+  end # of #set
+
+
+  describe "#to_ot" do
+
+    it "returns an Octothorpe made of the attribute columns, including the missing ID field" do
+      m1 = customer_model_class.new
+      expect( m1.to_ot ).to be_a_kind_of Octothorpe
+      expect( m1.to_ot.to_h ).to eq( {id: nil, name: nil, price:nil, groups:nil} )
+
+      m2 = customer_model_class.new(1)
+      m2.read
+      expect( m2.to_ot ).to be_a_kind_of Octothorpe
+      expect( m2.to_ot ).to eq records_as_ot[0]
+
+      m2 = customer_model_class.new(2)
+      m2.read
+      expect( m2.to_ot ).to be_a_kind_of Octothorpe
+      expect( m2.to_ot ).to eq records_as_ot[1] 
+    end
+
+  end # of #to_ot
+
+
+  describe "#map_to_model" do
+
+    it "sets the columns" do
+      cm = customer_model_class.new
+      cm.map_to_model(records.last)
+
+      expect( cm.groups ).to eq "trains,school"
+    end
+
+  end # of #map_to_model
+
+
+  describe "#map_to_interface" do
+
+    it "returns the columns" do
+      cm = customer_model_class.new
+      cm.map_to_model(records.last)
+
+      expect( cm.map_to_interface ).to be_an Octothorpe
+      expect( cm.map_to_interface.>>.groups ).to eq( "trains,school" )
+    end
+
+    it "includes the ID field" do
+      cm = customer_model_class.new(2).read
+
+      expect( cm.map_to_interface ).to be_an Octothorpe
+      expect( cm.map_to_interface.keys ).to include(:id)
+    end
+
+  end # of #map_to_interface
+
+
+  describe "#create" do
+
+    it "calls map_to_interface to get record data" do
+      m = customer_model_class.new(5)
+
+      expect( m ).to receive(:map_to_interface).and_call_original
+
+      m.name = "Lurch"
+      m.create
+    end
+
+  end # of #create
+
+
+  describe "#read" do
+
+    it "calls read on the interface" do
+      expect( model.interface ).to receive(:read).with(2).and_call_original
+      model.read
+    end
+
+    it "sets the attribute columns using map_to_model" do
+      ot = records_as_ot.last
+      allow( model.interface ).to receive(:read).and_return( ot )
+
+      cm = customer_model_class.new(1).read
+      expect( cm.name  ).to eq ot.>>.name
+      expect( cm.price ).to eq ot.>>.price
+      expect( cm.groups ).to eq ot.>>.groups
+    end
+
+    context "if the interface.read returns an empty Octothorpe" do
+      let(:missing) { customer_model_class.new(99) }
+
+      it "doesn't throw an exception" do
+        expect{ missing.read }.not_to raise_exception
+      end
+
+      it "raises an error alert" do
+        expect( missing.read.model_status ).to eq :error
+        expect( missing.read.alerts.first.type ).to eq :error
+      end
+    end
+
+  end # of #read
+
+
+  describe "#update" do
+
+    it "raises a Pod4Error if model status is :unknown" do
+      expect( model.model_status ).to eq :unknown
+      expect{ model.update }.to raise_exception Pod4::Pod4Error
+    end
+
+    it "raises a Pod4Error if model status is :deleted" do
+      model2.delete
+      expect{ model2.update }.to raise_exception Pod4::Pod4Error
+    end
+
+    it "calls map_to_interface to get record data" do
+      expect( model3 ).to receive(:map_to_interface)
+      model3.update
+    end
+
+  end # of #update
+
+
+  describe "#delete" do
+
+    it "raises a Pod4Error if model status is :unknown" do
+      expect( model.model_status ).to eq :unknown
+      expect{ model.delete }.to raise_exception Pod4::Pod4Error
+    end
+
+    it "raises a Pod4Error if model status is :deleted"do
+      model2.delete
+      expect{ model2.delete }.to raise_exception Pod4::Pod4Error
+    end
+
+    it "still gives you full access to the data after a delete" do
+      model2.delete
+
+      expect( model2.name  ).to eq records_as_ot[2].>>.name
+      expect( model2.price ).to eq records_as_ot[2].>>.price
+    end
+
+    it "sets status to :deleted" do
+      model2.delete
+      expect( model2.model_status ).to eq :deleted
+    end
+
+  end # of #delete
+
+end
+