pod4 0.8.0 → 0.8.1

data/spec/common/model_spec.rb

@@ -4,57 +4,50 @@ require 'pod4/model'
 require 'pod4/null_interface'
 
 
-##
-# We define a model class to test, since in normal operation we would never use
-# Model directly, and since it needs an inner Interface.
-#
-# We can't use a mock for the interface -- class definitions fall outside the
-# RSpec DSL as far as I can tell, so I can neither create a mock here or inject
-# it. Which means we can't mock the interface in the rest of the test either;
-# any mock we created would not get called.
-#
-# But: we want to test that Model calls Interface correctly.
-#
-# We do have what appears to be a perfectly sane way of testing. We can define
-# an inner class based on the genuinely existing, non-mock NullInterface class;
-# and then define expectations on it. When we do this, Rspec fails to pass the
-# call on to the object, unless we specifically say `.and_call_original`
-# instead of `.and_return`. 
-#
-# This is actually quite nice, but more than a little confusing when you see it
-# for the first time. Its use isn't spelled out in the RSpec docs AFAICS. 
-#
-class CustomerModel < Pod4::Model
-  attr_columns :id, :name, :groups
-  attr_columns :price  # specifically testing multiple calls to attr_columns
-  set_interface NullInterface.new(:id, :name, :price, :groups, [])
-
-  def map_to_model(ot)
-    super
-    @groups = @groups ? @groups.split(',') : []
-    self
-  end
-
-  def map_to_interface
-    x = super
-    g = (x.>>.groups || []).join(',')
-    x.merge(groups: g)
-  end
-
-  def fake_an_alert(*args)
-    add_alert(*args) #private method
-  end
+describe 'CustomerModel' do
 
-  def validate 
-    add_alert(:error, "falling over now") if name == "fall over"
-  end
+  ##
+  # We define a model class to test, since in normal operation we would never use Model directly,
+  # and since it needs an inner Interface.
+  #
+  # We define an inner class based on the genuinely existing, non-mock NullInterface class; and
+  # then define expectations on it. When we do this, Rspec fails to pass the call on to the object,
+  # unless we specifically say `.and_call_original` instead of `.and_return`. 
+  #
+  # This is actually quite nice, but more than a little confusing when you see it for the first
+  # time. Its use isn't spelled out in the RSpec docs AFAICS. 
+  #
+  # (Also, we define the class inside an Rspec 'let' so that its scope is limited to this test.)
+  #
+  let(:customer_model_class) do
+    Class.new Pod4::Model do
+      attr_columns :id, :name, :groups
+      attr_columns :price  # specifically testing multiple calls to attr_columns
+      set_interface NullInterface.new(:id, :name, :price, :groups, [])
+
+      def map_to_model(ot)
+        super
+        @groups = @groups ? @groups.split(',') : []
+        self
+      end
 
-  def reset_alerts; @alerts = []; end
-end
+      def map_to_interface
+        x = super
+        g = (x.>>.groups || []).join(',')
+        x.merge(groups: g)
+      end
 
+      def fake_an_alert(*args)
+        add_alert(*args) #private method
+      end
 
+      def validate 
+        add_alert(:error, "falling over now") if name == "fall over"
+      end
 
-describe 'CustomerModel' do
+      def reset_alerts; @alerts = []; end
+    end
+  end
 
   let(:records) do
     [ {id: 10, name: 'Gomez',     price: 1.23, groups: 'trains'       },
@@ -79,17 +72,17 @@ describe 'CustomerModel' do
   # 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) { CustomerModel.new(20) }
+  let(:model) { customer_model_class.new(20) }
 
   let(:model2) do
-    m = CustomerModel.new(30)
+    m = customer_model_class.new(30)
 
     allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[2]) )
     m.read.or_die
   end
 
   let(:model3) do
-    m = CustomerModel.new(40)
+    m = customer_model_class.new(40)
 
     allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[3]) )
     m.read.or_die
@@ -99,7 +92,7 @@ describe 'CustomerModel' do
   let(:thing) { Octothorpe.new(id: 'eek', name: 'thing',  price: 9.99, groups: 'scuttering') }
 
   let(:model4) do
-    m = CustomerModel.new('eek')
+    m = customer_model_class.new('eek')
 
     allow( m.interface ).to receive(:read).and_return(thing)
     m.read.or_die
@@ -111,18 +104,18 @@ describe 'CustomerModel' do
   describe 'Model.attr_columns' do
 
     it 'requires a list of columns' do
-      expect( CustomerModel ).to respond_to(:attr_columns).with(1).argument
+      expect( customer_model_class ).to respond_to(:attr_columns).with(1).argument
     end
 
     it 'exposes the columns just like attr_accessor' do
-      expect( CustomerModel.new ).to respond_to(:id)
-      expect( CustomerModel.new ).to respond_to(:name)
-      expect( CustomerModel.new ).to respond_to(:price)
-      expect( CustomerModel.new ).to respond_to(:groups)
-      expect( CustomerModel.new ).to respond_to(:id=)
-      expect( CustomerModel.new ).to respond_to(:name=)
-      expect( CustomerModel.new ).to respond_to(:price=)
-      expect( CustomerModel.new ).to respond_to(:groups=)
+      expect( customer_model_class.new ).to respond_to(:id)
+      expect( customer_model_class.new ).to respond_to(:name)
+      expect( customer_model_class.new ).to respond_to(:price)
+      expect( customer_model_class.new ).to respond_to(:groups)
+      expect( customer_model_class.new ).to respond_to(:id=)
+      expect( customer_model_class.new ).to respond_to(:name=)
+      expect( customer_model_class.new ).to respond_to(:price=)
+      expect( customer_model_class.new ).to respond_to(:groups=)
     end
 
     # it adds the columns to Model.columns -- covered by the columns test
@@ -132,7 +125,7 @@ describe 'CustomerModel' do
 
   describe 'Model.columns' do
     it 'lists the columns' do
-      expect( CustomerModel.columns ).to match_array( [:id,:name,:price,:groups] )
+      expect( customer_model_class.columns ).to match_array( [:id,:name,:price,:groups] )
     end
   end
   ##
@@ -140,7 +133,7 @@ describe 'CustomerModel' do
 
   describe 'Model.set_interface' do
     it 'requires an Interface object' do
-      expect( CustomerModel ).to respond_to(:set_interface).with(1).argument
+      expect( customer_model_class ).to respond_to(:set_interface).with(1).argument
     end
 
     # it 'sets interface' - covered by the interface test
@@ -150,8 +143,8 @@ describe 'CustomerModel' do
   
   describe 'Model.interface' do
     it 'is the interface object' do
-      expect( CustomerModel.interface ).to be_a_kind_of NullInterface
-      expect( CustomerModel.interface.id_fld ).to eq :id
+      expect( customer_model_class.interface ).to be_a_kind_of NullInterface
+      expect( customer_model_class.interface.id_fld ).to eq :id
     end
   end
   ##
@@ -159,7 +152,7 @@ describe 'CustomerModel' do
 
   describe 'Model.list' do
 
-    let(:list1) { CustomerModel.list }
+    let(:list1) { customer_model_class.list }
 
     def arr_without_groups(arr)
       arr
@@ -169,21 +162,21 @@ describe 'CustomerModel' do
     end
 
     it 'allows an optional selection parameter' do
-      expect{ CustomerModel.list                }.not_to raise_exception
-      expect{ CustomerModel.list(name: 'Betty') }.not_to raise_exception
+      expect{ customer_model_class.list                }.not_to raise_exception
+      expect{ customer_model_class.list(name: 'Betty') }.not_to raise_exception
     end
 
-    it 'returns an array of CustomerModel records' do
-      expect( CustomerModel.interface ).
+    it 'returns an array of customer_model_class records' do
+      expect( customer_model_class.interface ).
         to receive(:list).with(nil).
         and_return( records_as_ot )
 
       expect( list1 ).to be_a_kind_of Array
-      expect( list1 ).to all(be_a_kind_of CustomerModel)
+      expect( list1 ).to all(be_a_kind_of customer_model_class)
     end
 
     it 'returns the data from the interface' do
-      expect( CustomerModel.interface ).
+      expect( customer_model_class.interface ).
         to receive(:list).with(nil).
         and_return(records_as_ot)
 
@@ -194,11 +187,11 @@ describe 'CustomerModel' do
     it 'honours passed selection criteria' do
       hash = {price: 2.22}
 
-      expect( CustomerModel.interface ).
+      expect( customer_model_class.interface ).
         to receive(:list).with(hash).
         and_return( [Octothorpe.new(records[1])] )
 
-      list2 = CustomerModel.list(hash)
+      list2 = customer_model_class.list(hash)
       expect( list2.size ).to eq 1
       expect( arr_without_groups(list2).first ).to eq( recordsx[1] )
     end
@@ -206,23 +199,23 @@ describe 'CustomerModel' do
     it 'returns an empty array if nothing matches' do
       hash = {price: 1.23}
 
-      expect( CustomerModel.interface ).
+      expect( customer_model_class.interface ).
         to receive(:list).with(hash).
         and_return([])
 
-      expect( CustomerModel.list(hash) ).to eq []
+      expect( customer_model_class.list(hash) ).to eq []
     end
 
     it 'returns an empty array if there are no records' do
-      expect( CustomerModel.list ).to eq []
+      expect( customer_model_class.list ).to eq []
     end
 
     it 'calls map_to_model to set the record data' do
-      allow( CustomerModel.interface ).
+      allow( customer_model_class.interface ).
         to receive(:list).
         and_return(records_as_ot)
 
-      expect( CustomerModel.list.last.groups ).to eq(['trains', 'school'])
+      expect( customer_model_class.list.last.groups ).to eq(['trains', 'school'])
     end
 
   end
@@ -232,25 +225,25 @@ describe 'CustomerModel' do
   describe '#new' do
 
     it 'takes an optional ID' do
-      expect{ CustomerModel.new    }.not_to raise_exception
-      expect{ CustomerModel.new(1) }.not_to raise_exception
+      expect{ customer_model_class.new    }.not_to raise_exception
+      expect{ customer_model_class.new(1) }.not_to raise_exception
     end
 
     it 'sets the ID attribute' do
-      expect( CustomerModel.new(23).model_id ).to eq 23
+      expect( customer_model_class.new(23).model_id ).to eq 23
     end
 
     it 'sets the status to empty' do
-      expect( CustomerModel.new.model_status ).to eq :empty
+      expect( customer_model_class.new.model_status ).to eq :empty
     end
 
     it 'initializes the alerts attribute' do
-      expect( CustomerModel.new.alerts ).to eq([])
+      expect( customer_model_class.new.alerts ).to eq([])
     end
 
     it 'doesn''t freak out if the ID is not an integer' do
-      expect{ CustomerModel.new("france") }.not_to raise_exception
-      expect( CustomerModel.new("france").model_id ).to eq "france"
+      expect{ customer_model_class.new("france") }.not_to raise_exception
+      expect( customer_model_class.new("france").model_id ).to eq "france"
     end
 
   end
@@ -259,8 +252,8 @@ describe 'CustomerModel' do
 
   describe '#interface' do
     it 'returns the interface set in the class definition, again' do
-      expect( CustomerModel.new.interface ).to be_a_kind_of NullInterface
-      expect( CustomerModel.new.interface.id_fld ).to eq :id
+      expect( customer_model_class.new.interface ).to be_a_kind_of NullInterface
+      expect( customer_model_class.new.interface.id_fld ).to eq :id
     end
   end
   ##
@@ -269,7 +262,7 @@ describe 'CustomerModel' do
   describe '#columns' do
     it 'returns the attr_columns list from the class definition' do
 
-      expect( CustomerModel.new.columns ).
+      expect( customer_model_class.new.columns ).
         to match_array( [:id,:name,:price,:groups] )
 
     end
@@ -279,7 +272,7 @@ describe 'CustomerModel' do
 
   describe '#alerts' do
     it 'returns the list of alerts against the model' do
-      cm = CustomerModel.new
+      cm = customer_model_class.new
       cm.fake_an_alert(:warning, :foo, 'one')
       cm.fake_an_alert(:error,   :bar, 'two')
 
@@ -356,8 +349,8 @@ describe 'CustomerModel' do
 
   describe '#validate' do
     it 'takes no parameters' do
-      expect{ CustomerModel.new.validate(12) }.to raise_exception ArgumentError
-      expect{ CustomerModel.new.validate     }.not_to raise_exception
+      expect{ customer_model_class.new.validate(12) }.to raise_exception ArgumentError
+      expect{ customer_model_class.new.validate     }.not_to raise_exception
     end
   end
   ##
@@ -423,7 +416,7 @@ describe 'CustomerModel' do
   describe '#map_to_model' do
 
     it 'sets the columns, with groups as an array' do
-      cm = CustomerModel.new
+      cm = customer_model_class.new
       cm.map_to_model(records.last)
 
       expect( cm.groups ).to eq( ['trains','school'] )
@@ -436,7 +429,7 @@ describe 'CustomerModel' do
   describe '#map_to_interface' do
 
     it 'returns the columns, with groups as a list' do
-      cm = CustomerModel.new
+      cm = customer_model_class.new
       cm.map_to_model(records.last)
 
       expect( cm.map_to_interface.>>.groups ).to eq( 'trains,school' )
@@ -449,7 +442,7 @@ describe 'CustomerModel' do
   describe '#raise_exceptions' do
 
     it 'is also known as .or_die' do
-      cm = CustomerModel.new
+      cm = customer_model_class.new
       expect( cm.method(:raise_exceptions) ).to eq( cm.method(:or_die) )
     end
 
@@ -477,11 +470,11 @@ describe 'CustomerModel' do
 
   describe '#create' do
 
-    let (:new_model) { CustomerModel.new }
+    let (:new_model) { customer_model_class.new }
 
     it 'takes no parameters' do
-      expect{ CustomerModel.new.create(12) }.to raise_exception ArgumentError
-      expect{ CustomerModel.new.create     }.not_to raise_exception
+      expect{ customer_model_class.new.create(12) }.to raise_exception ArgumentError
+      expect{ customer_model_class.new.create     }.not_to raise_exception
     end
 
     it 'returns self' do
@@ -494,8 +487,8 @@ describe 'CustomerModel' do
     end
 
     it 'calls create on the interface if the record is good' do
-      expect( CustomerModel.interface ).to receive(:create)
-      CustomerModel.new.create
+      expect( customer_model_class.interface ).to receive(:create)
+      customer_model_class.new.create
 
       new_model.fake_an_alert(:warning, :name, 'foo')
       expect( new_model.interface ).to receive(:create)
@@ -558,8 +551,8 @@ describe 'CustomerModel' do
   describe '#read' do
 
     it 'takes no parameters' do
-      expect{ CustomerModel.new.create(12) }.to raise_exception ArgumentError
-      expect{ CustomerModel.new.create     }.not_to raise_exception
+      expect{ customer_model_class.new.create(12) }.to raise_exception ArgumentError
+      expect{ customer_model_class.new.create     }.not_to raise_exception
     end
 
     it 'returns self ' do
@@ -591,7 +584,7 @@ describe 'CustomerModel' do
       ot = records_as_ot.last
       allow( model.interface ).to receive(:read).and_return( ot )
 
-      cm = CustomerModel.new(10).read
+      cm = customer_model_class.new(10).read
       expect( cm.id    ).to eq ot.>>.id
       expect( cm.name  ).to eq ot.>>.name
       expect( cm.price ).to eq ot.>>.price
@@ -619,11 +612,11 @@ describe 'CustomerModel' do
     it 'doesn\'t freak out if the model is non-integer' do
       allow( model.interface ).to receive(:read).and_return( thing )
 
-      expect{ CustomerModel.new('eek').read }.not_to raise_error
+      expect{ customer_model_class.new('eek').read }.not_to raise_error
     end
 
     context 'if the interface.read returns an empty Octothorpe' do
-      let(:missing) { CustomerModel.new(99) }
+      let(:missing) { customer_model_class.new(99) }
 
       it 'doesn\'t throw an exception' do
         expect{ missing.read }.not_to raise_exception

data/spec/common/nebulous_interface_spec.rb

@@ -1,42 +1,21 @@
 require 'pod4/nebulous_interface'
 
 require 'nebulous_stomp'
-require 'nebulous_stomp/nebrequest_null'
+require 'nebulous_stomp/stomp_handler_null'
 
 require_relative 'shared_examples_for_interface'
 
 
 ##
-# In order to conform with 'acts_like an interface', our CRUDL routines must
-# pass a single value as the record, which we are making an array. When you
-# subclass NebulousInterface for your model, you don't have to follow that; you
-# can have a parameter per nebulous parameter, if you want, buy overriding the
-# CRUDL methods.
+# This is the class we will pass an instance of to NebulousInterface to use as a cut-out for
+# creating Nebulous::NebRequest objects.  
 #
-class TestNebulousInterface < NebulousInterface
-  set_target 'faketarget'
-  set_id_fld :id
-
-  set_verb :create, 'custcreate', :name, :price
-  set_verb :read,   'custread',   :id
-  set_verb :update, 'custupdate', :id, :name, :price
-  set_verb :delete, 'custdelete', :id
-  set_verb :list,   'custlist',   :name
-end
-##
-
-
-##
-# This is the class we will pass an instance of to NebulousInterface to use as
-# a cut-out for creating Nebulous::NebRequest objects.  
-#
-# If we pass an instance of this class to NebulousInterface it will call our
-# send method instead of creating a NebRequest instance by itself. (It expects
-# send to return a Nebrequest instance, or something that behaves like one.)
+# If we pass an instance of this class to NebulousInterface it will call our send method instead of
+# creating a Request instance by itself. (It expects send to return a Request instance, or
+# something that behaves like one.)
 #
-# This means we can cut Nebulous out of the loop and don't need a real
-# responder. We can also check the behaviour of NebulousInterface by using
-# RSpec 'inspect' syntax on our cutout object.
+# This means we can cut Nebulous out of the loop and don't need a real responder. We can also check
+# the behaviour of NebulousInterface by using RSpec 'inspect' syntax on our cutout object.
 #
 # We're basically emulating both a responder and a data source here (!)
 #
@@ -44,68 +23,72 @@ class FakeRequester
 
   def initialize(data={}); @data = data; end
 
+  ##
+  # NebulousInterface will call this to return a NebulousStomp::Request object, or something that
+  # behaves like one.
+  #
+  def send(target, requestmsg)
+    hash = response_message_hash(requestmsg)
+
+    stomphandler = NebulousStomp::StompHandlerNull.new
+
+    request = NebulousStomp::Request.new(target, requestmsg)
+    request.stomp_handler = stomphandler
+
+    hash[:inReplyTo] = request.message.reply_id
+    responsemsg  = NebulousStomp::Message.new hash
+    stomphandler.insert_fake(responsemsg)
+
+    request
+  end
+
+  private
+
+  def create(name, price)
+    id = @data.keys.sort.last.to_i + 1
+    @data[id] = {id: id, name: name, price: price.to_f}
+    id
+  end
+
+  def update(id, name, price)
+    return nil unless @data[id.to_i]
+    @data[id.to_i] = {id: id.to_i, name: name, price: price.to_f}
+  end
 
-  def send(verb, paramStr, withCache)
-    array = (paramStr || '').split(',')
+  def response_message_hash(requestmsg)
+    hash1 = { contentType: 'application/json' }
 
-    hash1 = { stompHeaders: nil,
-              stompBody:    '',
-              verb:         '',
-              params:       '',
-              desc:         '',
-              replyTo:      nil,
-              replyId:      nil,
-              inReplyTo:    nil,
-              contentType:  'application/json' }
+    if requestmsg.params.is_a?(Array)
+      array    = requestmsg.params
+      paramstr = array.join(',')
+    else
+      paramstr = requestmsg.params.to_s
+      array    = paramstr.split(',')
+    end
 
-    case verb
+    case requestmsg.verb
       when 'custcreate'
         id = create(*array)
         hash2 = {verb: 'success', params: id.to_s}
 
       when 'custread'
-        record = @data[paramStr.to_i]
+        record = @data[paramstr.to_i]
         hash2  = { stompBody: (record ? record.to_json : ''.to_json) }
 
       when 'custupdate'
         hash2 = update(*array) ? {verb: 'success'} : {verb: 'error' }
 
       when 'custdelete'
-        hash2 = 
-          if @data.delete(paramStr.to_i)
-            {verb: 'success'} 
-          else
-            {verb: 'error'}
-          end
+        hash2 = @data.delete(paramstr.to_i) ? {verb: 'success'} : {verb: 'error'}
 
       when 'custlist'
         subset = @data.values
-        if paramStr && !array[0].empty?
-          subset.select!{|x| x[:name] == array[0] }
-        end
+        subset.select!{|x| x[:name] == array[0] } if (!paramstr.empty? && !array[0].empty?)
         hash2 = { stompBody: subset.to_json }
 
     end
 
-    req = NebulousStomp::NebRequestNull.new('faketarget', verb, paramStr)
-    hash2[:inReplyTo] = req.replyID
-
-    mess = NebulousStomp::Message.from_cache( hash1.merge(hash2).to_json )
-    req.insert_fake_stomp(mess)
-    req
-  end
-
-
-  def create(name, price)
-    id = @data.keys.sort.last.to_i + 1
-    @data[id] = {id: id, name: name, price: price.to_f}
-    id
-  end
-
-
-  def update(id, name, price)
-    return nil unless @data[id.to_i]
-    @data[id.to_i] = {id: id.to_i, name: name, price: price.to_f}
+    hash1.merge(hash2)
   end
 
 end
@@ -113,7 +96,28 @@ end
 
 
 
-describe TestNebulousInterface do
+describe "NebulousInterface" do
+
+  ##
+  # In order to conform with 'acts_like an interface', our CRUDL routines must
+  # pass a single value as the record, which we are making an array. When you
+  # subclass NebulousInterface for your model, you don't have to follow that; you
+  # can have a parameter per nebulous parameter, if you want, buy overriding the
+  # CRUDL methods.
+  #
+  let(:nebulous_interface_class) do
+    Class.new NebulousInterface do
+      set_target 'faketarget'
+      set_id_fld :id
+
+      set_verb :create, 'custcreate', :name, :price
+      set_verb :read,   'custread',   :id
+      set_verb :update, 'custupdate', :id, :name, :price
+      set_verb :delete, 'custdelete', :id
+      set_verb :list,   'custlist',   :name
+    end
+  end
+
 
   def init_nebulous
     stomp_hash = { hosts: [{ login:    'guest',
@@ -142,7 +146,7 @@ describe TestNebulousInterface do
 
     let(:interface) do 
       init_nebulous
-      TestNebulousInterface.new( FakeRequester.new )
+      nebulous_interface_class.new( FakeRequester.new )
     end
 
   end
@@ -157,14 +161,14 @@ describe TestNebulousInterface do
 
   let(:interface) do
     init_nebulous
-    TestNebulousInterface.new( FakeRequester.new(data) )
+    nebulous_interface_class.new( FakeRequester.new(data) )
   end
 
 
   describe '#new' do
 
     it 'requires no parameters' do
-      expect{ TestNebulousInterface.new }.not_to raise_exception
+      expect{ nebulous_interface_class.new }.not_to raise_exception
     end
 
   end