pod4 0.10.6 → 1.0.0

data/spec/common/model_plus_encrypting_spec.rb

@@ -33,7 +33,10 @@ describe "(Model with Encryption)" do
       encrypted_columns :name, :ailment, :prescription
       set_key "dflkasdgklajndgn"
       set_iv_column :nonce
-      set_interface NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
+
+      ifce = NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
+      ifce.id_ai = false
+      set_interface ifce
     end
   end
 
@@ -44,7 +47,10 @@ describe "(Model with Encryption)" do
       encrypted_columns :name, :ailment, :prescription
       set_key "d"
       set_iv_column :nonce
-      set_interface NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
+
+      ifce = NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
+      ifce.id_ai = false
+      set_interface ifce
     end
   end
 
@@ -55,7 +61,10 @@ describe "(Model with Encryption)" do
       encrypted_columns :name, :ailment, :prescription
       set_key nil
       set_iv_column :nonce
-      set_interface NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
+
+      ifce =  NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
+      ifce.id_ai = false
+      set_interface ifce
     end
   end
 
@@ -65,7 +74,10 @@ describe "(Model with Encryption)" do
       attr_columns :id, :date, :heading, :text
       encrypted_columns :heading, :text
       set_key "dflkasdgklajndgn"
-      set_interface NullInterface.new(:id, :date, :heading, :text, [])
+
+      ifce = NullInterface.new(:id, :date, :heading, :text, [])
+      ifce.id_ai = false
+      set_interface ifce
     end
   end
 

data/spec/common/model_plus_tweaking_spec.rb

@@ -0,0 +1,128 @@
+require "octothorpe"
+require "bigdecimal"
+
+require "pod4"
+require "pod4/tweaking"
+require "pod4/interface"
+
+
+describe "(Model plus Tweaking)" do
+
+# ## 
+# # I can't use NullInterface this time because I need to define a custom method on the interface.
+# # But I'm _only_ calling that custom method, and there is nothing to say that the custom method
+# # actually has to talk to a database...
+# #
+# let(:customer_interface_class) do
+#   Class.new Pod4::Interface do
+#     
+#     def my_list(*args)
+#     end
+#   end
+# end
+
+  let(:customer_model_class) do
+    Class.new Pod4::Model do
+      include Pod4::Tweaking
+
+      class MyInterface < Pod4::Interface
+        attr_writer :response
+
+        # stuff that lets us fake being an interface
+        def initialize;      end
+        def id_fld;     :id; end
+
+        def test;  end # something we can use to test attr_columns method
+        def thing; end # there's already a method called this on the model
+
+        # main test method; responds with whatever we want it to
+        def my_list(*args)
+          @response
+        end
+      end
+
+      attr_columns    :id, :code, :band
+      set_interface   MyInterface.new
+      set_custom_list :my_list
+
+      def thing; end  
+
+    end
+  end
+
+
+  describe "Model.set_custom_list" do
+
+    it "requires the name of a method" do
+      expect{ customer_model_class.set_custom_list()         }.to raise_error ArgumentError
+      expect{ customer_model_class.set_custom_list(:test) }.not_to raise_error
+    end
+
+    it "raises an ArgumentError if the method does not exist on the interface" do
+      expect{ customer_model_class.set_custom_list(:nope) }.to raise_error ArgumentError
+    end
+
+    it "raises an ArgumentError if the method already exists on the model" do
+      expect{ customer_model_class.set_custom_list(:thing) }.to raise_error ArgumentError
+    end
+
+    it "creates the corresponding method on the model class" do
+      expect( customer_model_class ).to respond_to :my_list
+    end 
+
+  end # of Model.set_custom_list
+
+
+  describe "(custom method on model)" do
+
+    it "passes the arguments given it through to the interface method of the same name" do
+      expect( customer_model_class.interface )
+        .to receive(:my_list).with(:foo, 1, "bar")
+        .and_call_original
+
+      customer_model_class.interface.response = []
+      customer_model_class.my_list(:foo, 1, "bar")
+    end
+
+    it "raises Pod4Error if the return value is not an Array" do
+      customer_model_class.interface.response = :nope
+      expect{ customer_model_class.my_list(:foo) }.to raise_error(Pod4Error, /array/i)
+    end
+
+    it "raises Pod4Error if the return value is not an Array of Octothorpe/Hash" do
+      customer_model_class.interface.response = [:nope]
+      expect{ customer_model_class.my_list }.to raise_error(Pod4Error, /hash|record/i)
+    end
+
+    it "raises Pod4Error if any of the returned Octothorpe/Hashes are missing the ID field" do
+      customer_model_class.interface.response = [{id: 1, code: "one"}, {code: 2}]
+      expect{ customer_model_class.my_list }.to raise_error(Pod4Error, /ID/i)
+    end
+
+    it "returns an empty array if the interface method returns an empty array" do
+      customer_model_class.interface.response = []
+      expect{ customer_model_class.my_list }.not_to raise_error
+      expect( customer_model_class.my_list ).to eq([])
+    end
+
+    it "returns an array of model instances based on the results of the interface method" do
+      rows = [ {id: 1, code: "one"},
+               {id: 3, code: "three"},
+               {id: 5, code: "five", band: 12} ]
+
+      customer_model_class.interface.response = rows
+      list = customer_model_class.my_list
+
+      expect( list ).to be_an Array
+      expect( list ).to all( be_a customer_model_class )
+      expect( list.map(&:id)   ).to match_array( rows.map{|x| x[:id]} )
+      expect( list.map(&:code) ).to match_array( rows.map{|x| x[:code]} )
+      expect( list.find{|x| x.id == 5}.band ).to eq 12
+    end
+
+
+  end # of (custom method on model)
+  
+  
+end
+

data/spec/common/model_plus_typecasting_spec.rb

@@ -6,14 +6,16 @@ require "pod4/typecasting"
 require "pod4/null_interface"
 
 
-describe "ProductModel" do
+describe "(Model plus typecasting)" do
 
   let(:product_model_class) do
     Class.new Pod4::Model do
       include Pod4::TypeCasting
       force_encoding Encoding::ISO_8859_1   # I assume we are running as UTF8 here
       attr_columns :id, :code, :product, :price
-      set_interface NullInterface.new(:id, :code, :product, :price, [])
+      ifce = NullInterface.new(:id, :code, :product, :price, [])
+      ifce.id_ai = false
+      set_interface ifce
     end
   end
 
@@ -28,8 +30,12 @@ describe "ProductModel" do
       typecast :flag,     as: :boolean
       typecast :foo,     use: :mycast, bar: 42
       typecast :bar,      as: Float 
-      set_interface NullInterface.new( :id, :code, :band, :sales, :created, :yrstart, 
-                                       :flag, :foo, :bar, [] )
+
+      ifce = NullInterface.new( :id, :code, :band, :sales, :created, :yrstart, 
+                                :flag, :foo, :bar, [] )
+
+      ifce.id_ai = false
+      set_interface ifce
 
       def mycast(value, opts); "blarg"; end
     end

data/spec/common/model_spec.rb

@@ -1,39 +1,35 @@
-require 'octothorpe'
+require "octothorpe"
 
-require 'pod4/model'
-require 'pod4/null_interface'
+require "pod4/model"
+require "pod4/null_interface"
 
 
-describe 'CustomerModel' do
+describe "Model" do
 
   ##
   # 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, [])
+
+      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"} ] )
 
       def map_to_model(ot)
         super
-        @groups = @groups ? @groups.split(',') : []
+        @groups = @groups ? @groups.split(",") : []
         self
       end
 
       def map_to_interface
         x = super
-        g = (x.>>.groups || []).join(',')
+        g = (x.>>.groups || []).join(",")
         x.merge(groups: g)
       end
 
@@ -41,7 +37,7 @@ describe 'CustomerModel' do
         add_alert(*args) #private method
       end
 
-      def validate 
+      def validate(vmode)
         add_alert(:error, "falling over now") if name == "fall over"
       end
 
@@ -49,11 +45,36 @@ describe 'CustomerModel' do
     end
   end
 
+  # Here's a second model for a non-autoincrementing table
+  let(:product_model_class) do
+    Class.new Pod4::Model do
+      i = NullInterface.new(:code, :level, [{code: "foo", level: 1},
+                                            {code: "bar", level: 2}] )
+
+      i.id_ai = false
+
+      attr_columns :code, :level
+      set_interface i
+    end
+  end
+
+
+  def without_groups(ot)
+    ot.to_h.reject {|k,_| k == :groups}
+  end
+
+  def arr_without_groups(arr)
+    arr
+      .map {|m| without_groups(m.to_ot) }
+      .flatten
+
+  end
+
   let(:records) do
-    [ {id: 10, name: 'Gomez',     price: 1.23, groups: 'trains'       },
-      {id: 20, name: 'Morticia',  price: 2.34, groups: 'spanish'      },
-      {id: 30, name: 'Wednesday', price: 3.45, groups: 'school'       },
-      {id: 40, name: 'Pugsley',   price: 4.56, groups: 'trains,school'} ]
+    [ {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
 
@@ -64,50 +85,34 @@ describe 'CustomerModel' do
   let(:records_as_ot)  { records.map{|r| Octothorpe.new(r) } }
   let(:recordsx_as_ot) { recordsx.map{|r| Octothorpe.new(r) } }
 
-  def without_groups(ot)
-    ot.to_h.reject {|k,_| k == :groups}
-  end
-
   # 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.
+  # read(). We have two so that we can RSpec "allow" on one and not the other.
 
-  let(:model) { customer_model_class.new(20) }
+  let(:model) { customer_model_class.new(2) }
 
   let(:model2) do
-    m = customer_model_class.new(30)
+    m = customer_model_class.new(3)
 
-    allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[2]) )
+    #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(40)
+    m = customer_model_class.new(4)
 
-    allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[3]) )
+    #allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[3]) )
     m.read.or_die
   end
 
-  # Model4 is for a non-integer id
-  let(:thing) { Octothorpe.new(id: 'eek', name: 'thing',  price: 9.99, groups: 'scuttering') }
 
-  let(:model4) do
-    m = customer_model_class.new('eek')
+  describe "Model.attr_columns" do
 
-    allow( m.interface ).to receive(:read).and_return(thing)
-    m.read.or_die
-  end
-
-  ##
-
-
-  describe 'Model.attr_columns' do
-
-    it 'requires a list of columns' do
+    it "requires a list of columns" do
       expect( customer_model_class ).to respond_to(:attr_columns).with(1).argument
     end
 
-    it 'exposes the columns just like attr_accessor' do
+    it "exposes the columns just like attr_accessor" do
       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)
@@ -120,198 +125,168 @@ describe 'CustomerModel' do
 
     # it adds the columns to Model.columns -- covered by the columns test
   end
-  ##
 
 
-  describe 'Model.columns' do
-    it 'lists the columns' do
+  describe "Model.columns" do
+
+    it "lists the columns" do
       expect( customer_model_class.columns ).to match_array( [:id,:name,:price,:groups] )
     end
+
   end
-  ##
 
 
-  describe 'Model.set_interface' do
-    it 'requires an Interface object' do
+  describe "Model.set_interface" do
+
+    it "requires an Interface object" do
       expect( customer_model_class ).to respond_to(:set_interface).with(1).argument
     end
 
-    # it 'sets interface' - covered by the interface test
+    # it "sets interface" - covered by the interface test
   end
-  ##
 
   
-  describe 'Model.interface' do
-    it 'is the interface object' do
+  describe "Model.interface" do
+
+    it "is the interface object" do
       expect( customer_model_class.interface ).to be_a_kind_of NullInterface
       expect( customer_model_class.interface.id_fld ).to eq :id
     end
-  end
-  ##
 
+  end
 
-  describe 'Model.list' do
 
+  describe "Model.list" do
     let(:list1) { customer_model_class.list }
 
-    def arr_without_groups(arr)
-      arr
-        .map {|m| without_groups(m.to_ot) }
-        .flatten
-
-    end
-
-    it 'allows an optional selection parameter' do
+    it "allows an optional selection parameter" do
       expect{ customer_model_class.list                }.not_to raise_exception
-      expect{ customer_model_class.list(name: 'Betty') }.not_to raise_exception
+      expect{ customer_model_class.list(name: "Betty") }.not_to raise_exception
     end
 
-    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 )
-
+    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( customer_model_class.interface ).
-        to receive(:list).with(nil).
-        and_return(records_as_ot)
-
+    it "returns the data from the interface" do
       expect( list1.size ).to eq records.size
       expect( arr_without_groups(list1) ).to include( *recordsx )
     end
 
-    it 'honours passed selection criteria' do
-      hash = {price: 2.22}
-
-      expect( customer_model_class.interface ).
-        to receive(:list).with(hash).
-        and_return( [Octothorpe.new(records[1])] )
-
-      list2 = customer_model_class.list(hash)
-      expect( list2.size ).to eq 1
-      expect( arr_without_groups(list2).first ).to eq( recordsx[1] )
+    it "honours passed selection criteria" do
+      list = customer_model_class.list(price: 2.34)
+      expect( list.size ).to eq 1
+      expect( arr_without_groups(list).first ).to eq( recordsx[1] )
     end
 
-    it 'returns an empty array if nothing matches' do
-      hash = {price: 1.23}
-
-      expect( customer_model_class.interface ).
-        to receive(:list).with(hash).
-        and_return([])
-
-      expect( customer_model_class.list(hash) ).to eq []
+    it "returns an empty array if nothing matches" do
+      expect( customer_model_class.list(price: 3.21) ).to eq []
     end
 
-    it 'returns an empty array if there are no records' do
+    it "returns an empty array if there are no records" do
+      customer_model_class.list.each{|r| r.read; r.delete}
       expect( customer_model_class.list ).to eq []
     end
 
-    it 'calls map_to_model to set the record data' do
-      allow( customer_model_class.interface ).
-        to receive(:list).
-        and_return(records_as_ot)
-
-      expect( customer_model_class.list.last.groups ).to eq(['trains', 'school'])
+    it "calls map_to_model to set the record data" do
+      # groups is an array because we coded it to represent that way in the model above.
+      expect( customer_model_class.list.last.groups ).to eq(["trains", "school"])
     end
 
-  end
-  ##
+  end # of Model.list
 
 
-  describe '#new' do
+  describe "#new" do
 
-    it 'takes an optional ID' do
+    it "takes an optional ID" do
       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
+    it "sets the ID attribute" do
       expect( customer_model_class.new(23).model_id ).to eq 23
     end
 
-    it 'sets the status to empty' do
-      expect( customer_model_class.new.model_status ).to eq :empty
+    it "sets the status to unknown" do
+      expect( customer_model_class.new.model_status ).to eq :unknown
     end
 
-    it 'initializes the alerts attribute' do
+    it "initializes the alerts attribute" do
       expect( customer_model_class.new.alerts ).to eq([])
     end
 
-    it 'doesn''t freak out if the ID is not an integer' do
-      expect{ customer_model_class.new("france") }.not_to raise_exception
-      expect( customer_model_class.new("france").model_id ).to eq "france"
+    it "doesn't freak out if the non-autoincrementing ID is not an integer" do
+      expect{ product_model_class.new("france") }.not_to raise_exception
+      expect( product_model_class.new("france").model_id ).to eq "france"
     end
 
-  end
-  ##
+  end # of #new
 
 
-  describe '#interface' do
-    it 'returns the interface set in the class definition, again' do
+  describe "#interface" do
+
+    it "returns the interface set in the class definition, again" do
       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
-  ##
+
+  end # of #interface
 
 
-  describe '#columns' do
-    it 'returns the attr_columns list from the class definition' do
+  describe "#columns" do
 
+    it "returns the attr_columns list from the class definition" do
       expect( customer_model_class.new.columns ).
         to match_array( [:id,:name,:price,:groups] )
 
     end
-  end
-  ##
 
+  end # of #columns
 
-  describe '#alerts' do
-    it 'returns the list of alerts against the model' do
+
+  describe "#alerts" do
+
+    it "returns the list of alerts against the model" do
       cm = customer_model_class.new
-      cm.fake_an_alert(:warning, :foo, 'one')
-      cm.fake_an_alert(:error,   :bar, 'two')
+      cm.fake_an_alert(:warning, :foo, "one")
+      cm.fake_an_alert(:error,   :bar, "two")
 
       expect( cm.alerts.size ).to eq 2
       expect( cm.alerts.map{|a| a.message} ).to match_array(%w|one two|)
     end
-  end
-  ##
 
+  end # of #alerts
 
-  describe '#add_alert' do
-    # add_alert is a protected method, which is only supposed to be called
-    # within the validate method of a subclass of Method. So we test it by
-    # calling our alert faking method
 
-    it 'requires type, message or type, field, message' do
+  describe "#add_alert" do
+    # add_alert is a private method, which is only supposed to be called within a subclass of
+    # Model. So we test it by calling our alert faking method
+
+    it "requires type, message or type, field, message" do
       expect{ model.fake_an_alert        }.to raise_exception ArgumentError
       expect{ model.fake_an_alert(nil)   }.to raise_exception ArgumentError
-      expect{ model.fake_an_alert('foo') }.to raise_exception ArgumentError
+      expect{ model.fake_an_alert("foo") }.to raise_exception ArgumentError
 
-      expect{ model.fake_an_alert(:error, 'foo') }.not_to raise_exception
-      expect{ model.fake_an_alert(:warning, :name, 'bar') }.
+      expect{ model.fake_an_alert(:error, "foo") }.not_to raise_exception
+      expect{ model.fake_an_alert(:warning, :name, "bar") }.
         not_to raise_exception
 
     end
 
-    it 'only allows valid types' do
+    it "only allows valid types" do
       [:brian, :werning, nil, :alert, :danger].each do |l|
-        expect{ model.fake_an_alert(l, 'foo') }.to raise_exception ArgumentError
+        expect{ model.fake_an_alert(l, "foo") }.to raise_exception ArgumentError
       end
 
       [:warning, :error, :success, :info].each do |l|
-        expect{ model.fake_an_alert(l, 'foo') }.not_to raise_exception
+        expect{ model.fake_an_alert(l, "foo") }.not_to raise_exception
       end
 
     end
 
-    it 'creates an Alert and adds it to @alerts' do
-      lurch = 'Dnhhhhhh'
+    it "creates an Alert and adds it to @alerts" do
+      lurch = "Dnhhhhhh"
       model.fake_an_alert(:error, :price, lurch)
 
       expect( model.alerts.size ).to eq 1
@@ -319,39 +294,37 @@ describe 'CustomerModel' do
       expect( model.alerts.first.message ).to eq lurch
     end
 
-    it 'sets @model_status if the type is worse than @model_status' do
-      model.fake_an_alert(:warning, :price, 'xoo')
+    it "sets @model_status if the type is worse than @model_status" do
+      model.fake_an_alert(:warning, :price, "xoo")
       expect( model.model_status ).to eq :warning
 
-      model.fake_an_alert(:success, :price, 'flom')
+      model.fake_an_alert(:success, :price, "flom")
       expect( model.model_status ).to eq :warning
 
-      model.fake_an_alert(:info, :price, 'flom')
+      model.fake_an_alert(:info, :price, "flom")
       expect( model.model_status ).to eq :warning
 
-      model.fake_an_alert(:error, :price, 'qar')
+      model.fake_an_alert(:error, :price, "qar")
       expect( model.model_status ).to eq :error
 
-      model.fake_an_alert(:warning, :price, 'drazq')
+      model.fake_an_alert(:warning, :price, "drazq")
       expect( model.model_status ).to eq :error
     end
 
-    it 'ignores a new alert if identical to an existing one' do
-      lurch = 'Dnhhhhhh'
+    it "ignores a new alert if identical to an existing one" do
+      lurch = "Dnhhhhhh"
       2.times { model.fake_an_alert(:error, :price, lurch) }
 
       expect( model.alerts.size ).to eq 1
     end
 
-  end
-  ##
-
+  end # of #add_alert
 
-  describe '#set' do
 
+  describe "#set" do
     let (:ot) { records_as_ot[3] }
 
-    it 'takes an Octothorpe or a Hash' do
+    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
@@ -359,11 +332,11 @@ describe 'CustomerModel' do
       expect{ model.set(ot) }.not_to raise_exception 
     end
 
-    it 'returns self' do
+    it "returns self" do
       expect( model.set(ot) ).to eq model
     end
 
-    it 'sets the attribute columns from the hash' do
+    it "sets the attribute columns from the hash" do
       model.set(ot)
 
       expect( model.id    ).to eq ot.>>.id
@@ -371,270 +344,244 @@ describe 'CustomerModel' do
       expect( model.price ).to eq ot.>>.price
     end
     
-    it 'only sets the attributes on the model that it is given' do
-      otx = Octothorpe.new(name: 'Piggy', price: 98.76, weapon: 'rake')
+    it "only sets the attributes on the model that it is given" do
+      otx = Octothorpe.new(name: "Piggy", price: 98.76, weapon: "rake")
 
       expect{ model3.set(otx) }.not_to raise_exception
-      expect( model3.id     ).to eq 40
-      expect( model3.name   ).to eq 'Piggy'
+      expect( model3.id     ).to eq 4
+      expect( model3.name   ).to eq "Piggy"
       expect( model3.price  ).to eq 98.76
-      expect( model3.groups ).to eq( ot.>>.groups.split(',') )
+      expect( model3.groups ).to eq( ot.>>.groups.split(",") )
     end
 
-  end
-  ##
+  end # of #set
 
 
-  describe '#to_ot' do
-    it 'returns an Octothorpe made of the attribute columns' do
-      expect( model.to_ot ).to be_a_kind_of Octothorpe
+  describe "#to_ot" do
 
-      expect( model.to_ot.to_h ).
-        to eq( {id: nil, name: nil, price:nil, groups:nil} )
+    it "returns an Octothorpe made of the attribute columns, including the 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} )
 
-      model.map_to_model(records[1])
-      expect( model.to_ot ).to be_a_kind_of Octothorpe
-      expect( without_groups(model.to_ot) ).to eq recordsx[1]
+      m2 = customer_model_class.new(1)
+      m2.read
+      expect( m2.to_ot ).to be_a_kind_of Octothorpe
+      expect( without_groups(m2.to_ot) ).to eq recordsx[0]
 
-      model.map_to_model(records_as_ot[2])
-      expect( model.to_ot ).to be_a_kind_of Octothorpe
-      expect( without_groups(model.to_ot) ).to eq recordsx[2]
+      m3 = customer_model_class.new(2)
+      m3.read
+      expect( m3.to_ot ).to be_a_kind_of Octothorpe
+      expect( without_groups(m3.to_ot) ).to eq recordsx[1]
     end
-  end
-  ##
+
+  end # of #to_ot
 
 
-  describe '#map_to_model' do
+  describe "#map_to_model" do
+
+    it "sets the columns, with groups as an array" do
+      # testing the custom typecasting in customer_model_class
 
-    it 'sets the columns, with groups as an array' do
       cm = customer_model_class.new
       cm.map_to_model(records.last)
 
-      expect( cm.groups ).to eq( ['trains','school'] )
+      expect( cm.groups ).to eq( ["trains","school"] )
     end
 
-  end
-  ##
+  end # of #map_to_model
+
 
+  describe "#map_to_interface" do
 
-  describe '#map_to_interface' do
+    it "returns the columns, with groups as a list" do
+      # testing the custom typecasting in customer_model_class
 
-    it 'returns the columns, with groups as a list' do
       cm = customer_model_class.new
       cm.map_to_model(records.last)
 
-      expect( cm.map_to_interface.>>.groups ).to eq( 'trains,school' )
+      expect( cm.map_to_interface ).to be_an Octothorpe
+      expect( cm.map_to_interface.>>.groups ).to eq( "trains,school" )
     end
 
-  end
-  ##
+  end # of #map_to_interface
 
 
-  describe '#raise_exceptions' do
+  describe "#raise_exceptions" do
 
-    it 'is also known as .or_die' do
+    it "is also known as .or_die" do
       cm = customer_model_class.new
       expect( cm.method(:raise_exceptions) ).to eq( cm.method(:or_die) )
     end
 
-    it 'raises ValidationError if model status is :error' do
-      model.fake_an_alert(:error, :price, 'qar')
+    it "raises ValidationError if model status is :error" do
+      model.fake_an_alert(:error, :price, "qar")
       expect{ model.raise_exceptions }.to raise_exception Pod4::ValidationError
     end
 
-    it 'does nothing if model status is not :error' do
+    it "does nothing if model status is not :error" do
       expect{ model.raise_exceptions }.not_to raise_exception
 
-      model.fake_an_alert(:info, :price, 'qar')
+      model.fake_an_alert(:info, :price, "qar")
       expect{ model.raise_exceptions }.not_to raise_exception
 
-      model.fake_an_alert(:success, :price, 'qar')
+      model.fake_an_alert(:success, :price, "qar")
       expect{ model.raise_exceptions }.not_to raise_exception
 
-      model.fake_an_alert(:warning, :price, 'qar')
+      model.fake_an_alert(:warning, :price, "qar")
       expect{ model.raise_exceptions }.not_to raise_exception
     end
 
-  end
-  ##
-
+  end # of #raise_exceptions
 
-  describe '#create' do
 
+  describe "#create" do
     let (:new_model) { customer_model_class.new }
 
-    it 'takes no parameters' do
+    it "takes no parameters" do
       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
+    it "returns self" do
       expect( new_model.create ).to eq new_model
     end
 
-    it 'calls validate' do
-      # validation tests arity of the validate method; rspec freaks out. So we can't 
-      # `expect( new_model ).to receive(:validate)`
+    it "calls validate and passes the parameter" do
+      expect( new_model ).to receive(:validate).with(:create)
 
-      m = customer_model_class.new
-      m.name = "fall over"
-      m.create
-      expect( m.model_status ).to eq :error
+      new_model.name = "foo"
+      new_model.create
     end
 
-    it 'calls create on the interface if the record is good' do
+    it "calls create on the interface if the record is good" do
       expect( customer_model_class.interface ).to receive(:create)
       customer_model_class.new.create
 
-      new_model.fake_an_alert(:warning, :name, 'foo')
+      new_model.fake_an_alert(:warning, :name, "foo")
       expect( new_model.interface ).to receive(:create)
       new_model.create
     end
 
-
-    it 'doesnt call create on the interface if the record is bad' do
-      new_model.fake_an_alert(:error, :name, 'foo')
+    it "doesn't call create on the interface if the record is bad" do
+      new_model.fake_an_alert(:error, :name, "foo")
       expect( new_model.interface ).not_to receive(:create)
       new_model.create
     end
 
-    it 'sets the ID' do
-      new_model.id   = 50
-      new_model.name = "Lurch"
-      new_model.create
-
-      expect( new_model.model_id ).to eq 50
-    end
-
-    it 'sets model status to :okay if it was :empty' do
-      new_model.id   = 50
+    it "sets model status to :okay if it was :unknown" do
+      new_model.id   = 5
       new_model.name = "Lurch"
       new_model.create
 
       expect( new_model.model_status ).to eq :okay
     end
 
-    it 'leaves the model status alone if it was not :empty' do
-      new_model.id   = 50
+    it "leaves the model status alone if it was not :unknown" do
+      new_model.id   = 5
       new_model.name = "Lurch"
       new_model.create
 
-      new_model.fake_an_alert(:warning, :price, 'qar')
+      new_model.fake_an_alert(:warning, :price, "qar")
       expect( new_model.model_status ).to eq :warning
     end
 
-    it 'calls map_to_interface to get record data' do
-      allow( new_model.interface ).to receive(:create)
-      expect( new_model ).to receive(:map_to_interface)
+    it "calls map_to_interface to get record data" do
+      m = customer_model_class.new
 
-      new_model.id   = 50
-      new_model.name = "Lurch"
-      new_model.create
-    end
+      expect( m ).to receive(:map_to_interface).and_call_original
 
-    it 'doesn\'t freak out if the model is not an integer' do
-      expect( new_model.interface ).to receive(:create)
-      new_model.id   = "handy"
-      new_model.name = "Thing"
+      m.id   = 5
+      m.name = "Lurch"
+      m.create
+    end
 
-      expect{ new_model.create }.not_to raise_error
+    it "doesn't freak out if the ID field (non-autoincrementing) is not an integer" do
+      m = product_model_class.new("baz").read
+      m.level = 99
+      expect{ m.create }.not_to raise_error
     end
 
     it "creates an alert instead when the interface raises WeakError" do
       allow( new_model.interface ).to receive(:create).and_raise Pod4::WeakError, "foo"
 
-      new_model.id   = 50
+      new_model.id   = 5
       new_model.name = "Lurch"
       expect{ new_model.create }.not_to raise_exception
       expect( new_model.model_status ).to eq :error
       expect( new_model.alerts.map(&:message) ).to include( include "foo" )
     end
 
-  end
-  ##
+    it "updates @model_id" do
+      m = customer_model_class.new
+      m.id   = 5
+      m.name = "Lurch"
+      m.create
+
+      expect( m.model_id ).to eq 5
+    end
+
+  end # of #create
 
 
-  describe '#read' do
+  describe "#read" do
 
-    it 'takes no parameters' do
+    it "takes no parameters" do
       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
-      allow( model.interface ).
-        to receive(:read).
-        and_return( records_as_ot.first )
-
+    it "returns self" do
       expect( model.read ).to eq model
     end
 
-    it 'calls read on the interface' do
-      expect( model.interface ).
-        to receive(:read).
-        and_return( records_as_ot.first )
-
+    it "calls read on the interface" do
+      expect( model.interface ).to receive(:read).with(2).and_call_original
       model.read
     end
 
-    it 'calls validate' do
-      # again, because rspec is a bit stupid, we can't just `expect(model).to receive(:validate)`
-
-      allow( model.interface ).
-        to receive(:read).
-        and_return( records_as_ot.first.merge(name: "fall over") )
-
+    it "calls validate and passes the parameter" do
+      expect( model ).to receive(:validate).with(:read)
       model.read
-      expect( model.model_status ).to eq :error
     end
 
-    it 'sets the attribute columns using map_to_model' do
+    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(10).read
-      expect( cm.id    ).to eq ot.>>.id
+      cm = customer_model_class.new(4).read
       expect( cm.name  ).to eq ot.>>.name
       expect( cm.price ).to eq ot.>>.price
       expect( cm.groups ).to be_a_kind_of(Array)
-      expect( cm.groups ).to eq( ot.>>.groups.split(',') )
+      expect( cm.groups ).to eq( ot.>>.groups.split(",") )
     end
 
-    it 'sets model status to :okay if it was :empty' do
+    it "sets model status to :okay if it was :unknown" do
       ot = records_as_ot.last
-      allow( model.interface ).to receive(:read).and_return( ot )
-
       model.read
       expect( model.model_status ).to eq :okay
     end
 
-    it 'leaves the model status alone if it was not :empty' do
+    it "leaves the model status alone if it was not :unknown" do
       ot = records_as_ot.last
-      allow( model.interface ).to receive(:read).and_return( ot )
-
-      model.fake_an_alert(:warning, :price, 'qar')
+      model.fake_an_alert(:warning, :price, "qar")
       model.read
       expect( model.model_status ).to eq :warning
     end
 
-    it 'doesn\'t freak out if the model is non-integer' do
-      allow( model.interface ).to receive(:read).and_return( thing )
-
-      expect{ customer_model_class.new('eek').read }.not_to raise_error
+    it "doesn't freak out if the (non-autoincrementing) ID is non-integer" do
+      expect{ product_model_class.new("foo").read }.not_to raise_error
     end
 
-    context 'if the interface.read returns an empty Octothorpe' do
+    context "if the interface.read returns an empty Octothorpe" do
       let(:missing) { customer_model_class.new(99) }
 
-      it 'doesn\'t throw an exception' do
+      it "doesn't throw an exception" do
         expect{ missing.read }.not_to raise_exception
       end
 
-      it 'raises an error alert' do
+      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
 
     it "creates an alert instead when the interface raises WeakError" do
@@ -645,86 +592,74 @@ describe 'CustomerModel' do
       expect( model.alerts.map(&:message) ).to include( include "foo" )
     end
 
-  end
-  ##
+    it "updates @model_id" do
+      foo = product_model_class.new("foo")
+      foo.read
 
+      expect( foo.model_id ).to eq "foo"
+    end
 
-  describe '#update' do
+  end # of #read
 
-    before do
-      allow( model2.interface ).
-        to receive(:update).
-        and_return( model2.interface )
 
-    end
+  describe "#update" do
 
-    it 'takes no parameters' do
+    it "takes no parameters" do
       expect{ model2.update(12) }.to raise_exception ArgumentError
       expect{ model2.update     }.not_to raise_exception
     end
 
-    it 'returns self' do
+    it "returns self" do
       expect( model2.update ).to eq model2
     end
 
-    it 'raises a Pod4Error if model status is :empty' do
-      allow( model.interface ).to receive(:update).and_return( model.interface )
-
-      expect( model.model_status ).to eq :empty
+    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
+    it "raises a Pod4Error if model status is :deleted" do
       model2.delete
       expect{ model2.update }.to raise_exception Pod4::Pod4Error
     end
 
-    it 'calls validate' do
-      # again, we can't `expect(model2).to receive(:validate)` because we're testing arity there
-      model2.name = "fall over"
+    it "calls validate and passes the parameter" do
+      expect( model2 ).to receive(:validate).with(:update)
+
+      model2.name = "foo"
       model2.update
-      expect( model2.model_status ).to eq :error
     end
 
-    it 'calls update on the interface if the validation passes' do
-      expect( model3.interface ).
-        to receive(:update).
-        and_return( model3.interface )
+    it "calls update on the interface if the validation passes" do
+      expect( model3.interface ).to receive(:update)
 
       model3.update
     end
 
-    it 'doesn\'t call update on the interface if the validation fails' do
+    it "doesn't call update on the interface if the validation fails" do
       expect( model3.interface ).not_to receive(:update)
 
       model3.name = "fall over"  # triggers validation
       model3.update
     end
 
-    it 'calls map_to_interface to get record data' do
+    it "calls map_to_interface to get record data" do
       expect( model3 ).to receive(:map_to_interface)
       model3.update
     end
 
-    it 'doesn\'t freak out if the model is non-integer' do
-      expect( model4.interface ).
-        to receive(:update).
-        and_return( model4.interface )
-
-      model4.update
+    it "doesn't freak out if the (non_autoincrementing) ID is non-integer" do
+      m = product_model_class.new("bar").read
+      expect{ m.update }.not_to raise_error
     end
 
-    context 'when the record already has error alerts' do
-
-      it 'passes if there is no longer anything wrong' do
-        expect( model3.interface ).
-          to receive(:update).
-          and_return( model3.interface )
+    context "when the record already has error alerts" do
+      it "passes if there is no longer anything wrong" do
+        expect( model3.interface ).to receive(:update)
 
         model3.fake_an_alert(:error, "bad things")
         model3.update
       end
-
     end
 
     it "creates an alert instead when the interface raises WeakError" do
@@ -735,70 +670,59 @@ describe 'CustomerModel' do
       expect( model3.alerts.map(&:message) ).to include( include "foo" )
     end
 
-  end
-  ##
-
+    it "updates @model_id" do
+      foo = product_model_class.new("foo").read
+      foo.code = "bang"
+      foo.update
+      
+      expect( foo.model_id ).to eq "bang"
+    end
 
-  describe '#delete' do
+  end # of #update
 
-    before do
-      allow( model2.interface ).
-        to receive(:delete).
-        and_return( model2.interface )
 
-    end
+  describe "#delete" do
 
-    it 'takes no parameters' do
+    it "takes no parameters" do
       expect{ model2.delete(12) }.to raise_exception ArgumentError
       expect{ model2.delete     }.not_to raise_exception
     end
 
-    it 'returns self' do
+    it "returns self" do
       expect( model2.delete ).to eq model2
     end
 
-    it 'raises a Pod4Error if model status is :empty' do
-      allow( model.interface ).to receive(:delete).and_return( model.interface )
-
-      expect( model.model_status ).to eq :empty
+    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
+    it "raises a Pod4Error if model status is :deleted"do
       model2.delete
       expect{ model2.delete }.to raise_exception Pod4::Pod4Error
     end
 
-    it 'calls validate' do
-      # again, because rspec can't cope with us testing arity in Pod4::Model, we can't say
-      # `expect(model2).to receive(:validate)`. But for delete we are only running validation as a
-      # courtesy -- a validation fail does not stop the delete, it just sets alerts. So the model
-      # status should be :deleted and not :error
-      model2.name = "fall over"
+    it "calls validate and passes the parameter" do
+      expect( model2 ).to receive(:validate).with(:delete)
       model2.delete
-
-      # one of the elements of the alerts array should include the word "falling"
-      expect( model2.alerts.map(&:message) ).to include(include "falling")
     end
 
-    it 'calls delete on the interface if the model status is good' do
+    it "calls delete on the interface if the model status is good" do
       expect( model3.interface ).
-        to receive(:delete).
-        and_return( model3.interface )
+        to receive(:delete)
 
       model3.delete 
     end
 
-    it 'calls delete on the interface if the model status is bad' do
+    it "calls delete on the interface if the model status is bad" do
       expect( model3.interface ).
-        to receive(:delete).
-        and_return( model3.interface )
+        to receive(:delete)
 
-      model3.fake_an_alert(:error, :price, 'qar')
+      model3.fake_an_alert(:error, :price, "qar")
       model3.delete 
     end
 
-    it 'still gives you full access to the data after a delete' do
+    it "still gives you full access to the data after a delete" do
       model2.delete
 
       expect( model2.id    ).to eq records_as_ot[2].>>.id
@@ -806,17 +730,14 @@ describe 'CustomerModel' do
       expect( model2.price ).to eq records_as_ot[2].>>.price
     end
 
-    it 'sets status to :deleted' do
+    it "sets status to :deleted" do
       model2.delete
       expect( model2.model_status ).to eq :deleted
     end
 
-    it 'doesn\'t freak out if the model is non-integer' do
-      expect( model4.interface ).
-        to receive(:delete).
-        and_return( model4.interface )
-
-      model4.delete
+    it "doesn't freak out if the (non-autoincrementing) ID is non-integer" do
+      m = product_model_class.new("bar").read
+      expect{ m.delete }.not_to raise_error
     end
 
     it "creates an alert instead when the interface raises WeakError" do
@@ -826,8 +747,7 @@ describe 'CustomerModel' do
       expect( model3.alerts.map(&:message) ).to include( include "foo" )
     end
 
-  end
-  ##
+  end # of #delete
 
 end