amee-data-abstraction 1.0.0

data/lib/core-extensions/proc.rb

@@ -0,0 +1,15 @@
+# Copyright (C) 2011 AMEE UK Ltd. - http://www.amee.com
+# Released as Open Source Software under the BSD 3-Clause license. See LICENSE.txt for details.
+
+class Proc
+
+  # Shorthand method for calling <tt>self</tt> passing <tt>x</tt> as a block 
+  # variable.
+  # 
+  # This is required for ruby 1.8 only, as it mimics functionality added in
+  # version 1.9
+  #
+  def===(x)
+    call(x)
+  end
+end

data/rails/init.rb

@@ -0,0 +1,32 @@
+
+# Authors::   James Hetherington, James Smith, Andrew Berkeley, George Palmer
+# Copyright:: Copyright (c) 2011 AMEE UK Ltd
+# License::   Permission is hereby granted, free of charge, to any person obtaining
+#             a copy of this software and associated documentation files (the
+#             "Software"), to deal in the Software without restriction, including
+#             without limitation the rights to use, copy, modify, merge, publish,
+#             distribute, sublicense, and/or sell copies of the Software, and to
+#             permit persons to whom the Software is furnished to do so, subject
+#             to the following conditions:
+#
+#             The above copyright notice and this permission notice shall be included
+#             in all copies or substantial portions of the Software.
+#
+#             THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#             EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#             MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+#             IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+#             CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+#             TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+#             SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'amee-data-abstraction.rb'
+
+module AMEE::DataAbstraction
+
+  # Override the connection accessor to provide the global connection in rails apps
+  def self.connection
+    AMEE::Rails.connection
+  end
+
+end

data/spec/amee-data-abstraction/calculation_set_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+class CalculationSet
+  def call_me
+    #stub, because flexmock doesn't work for new instances during constructor
+    @@called=true
+  end
+  cattr_accessor :called
+end
+describe CalculationSet do
+  it 'can create an instance' do
+    ElectricityAndTransport.should be_a CalculationSet
+  end
+  it 'can create an instance' do
+    ElectricityAndTransport.calculations.should be_a ActiveSupport::OrderedHash
+  end
+  it 'can access a calculation by key' do
+    ElectricityAndTransport[:transport].should be_a PrototypeCalculation
+  end
+  it 'can construct a calculation' do
+    CalculationSet.new {calculation {label :mycalc}}[:mycalc].should be_a PrototypeCalculation
+  end
+  it 'can be initialized with a DSL block' do
+    CalculationSet.new {call_me}
+    CalculationSet.called.should be_true
+  end
+  it 'can have terms added to all calculations' do
+    cs=CalculationSet.new {
+      all_calculations {
+        drill {label :energetic}
+      }
+      calculation {
+        label :mycalc
+        drill {label :remarkably}
+      }
+    }
+    cs[:mycalc].drills.labels.should eql [:remarkably,:energetic]
+  end
+  it 'can make multiple calculations quickly, one for each usage' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.usages(['bybob','byfrank']).
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],'byfrank',[],nil,nil,true,false,nil,"TEXT").
+      item_value_definition('second',['bybob'],[],'byfrank',[],nil,nil,true,false,nil,"TEXT").
+      item_value_definition('third',['byfrank'],[],['bybob'],[],nil,nil,true,false,nil,"TEXT")
+    cs=CalculationSet.new {
+      calculations_all_usages('/something') { |usage|
+        label usage.to_sym
+        profiles_from_usage usage
+      }
+    }
+    cs[:bybob].profiles.labels.should eql [:first,:second]
+    cs[:byfrank].profiles.labels.should eql [:third]
+  end
+end

data/spec/amee-data-abstraction/calculation_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+describe Calculation do
+  
+  it 'can create an instance' do
+    Transport.should be_a Calculation
+  end
+  it 'should have ordered terms, with labels' do
+    Transport.terms.labels.should eql [:fuel,:size,:distance,:co2]
+  end
+  it 'should have amee paths for the terms' do
+    Transport.terms.paths.should eql ['fuel','size','distance',:default]
+  end
+  it 'should have human names for the terms' do
+    Transport.terms.names.
+      should eql ['Fuel Type','Vehicle Size','Distance Driven','Carbon Dioxide']
+  end
+  it 'should return the inputs' do
+    Transport.inputs.labels.should  eql [:fuel,:size,:distance]
+  end
+  it 'should return the outputs' do
+    Transport.outputs.labels.should  eql [:co2]
+  end
+  it 'should generate an explorer URL' do
+    Transport.explorer_url.should eql 'http://explorer.amee.com/categories/transport/car/generic'
+  end
+  it 'can return a term via []' do
+    Transport[:co2].label.should eql :co2
+  end
+  it 'when copied, should deep copy the values' do
+    x=Transport.clone
+    x[:co2].value :somevalue
+    x[:co2].value.should eql :somevalue
+    Transport[:co2].value.should be_nil
+  end
+  it 'knows to get terms that come before or after others' do
+    t=Transport.clone
+    t.before(:distance).labels.
+      should eql [:fuel,:size]
+    t.after(:distance).map(&:label).
+      should eql [:co2]
+  end
+  it 'delegates selectors to terms list' do
+    t=Transport.clone
+    t.drills.labels.should eql [:fuel,:size]
+  end
+  it 'can find its amee data category' do
+    t=Transport.clone
+    mocker=AMEEMocker.new self,:path=>'transport/car/generic'
+    mocker.data_category
+    t.send(:amee_data_category).path.should eql '/data/transport/car/generic'
+  end
+  it 'can find its amee item definition' do
+    mocker=AMEEMocker.new self,:path=>'transport/car/generic'
+    mocker.item_definition(:my_itemdef_name).data_category
+    t=Transport.clone
+    t.send(:amee_item_definition).name.should eql :my_itemdef_name
+  end
+  it 'can give item value definition list' do
+    mocker=AMEEMocker.new self,:path=>'transport/car/generic'
+    mocker.item_value_definition('distance').item_value_definitions.
+      item_definition.data_category
+    t=Transport.clone
+    t.send(:amee_ivds).first.path.should eql 'distance'
+  end
+  it 'can memoise access to  AMEE' do
+    t=Transport.clone
+    #AMEE::Data::Category.get(connection, "/data#{path}")
+    flexmock(AMEE::Data::Category).should_receive(:get).
+      with(AMEE::DataAbstraction.connection,'/data/transport/car/generic').
+      once.and_return(true)
+    t.send(:amee_data_category)
+    t.send(:amee_data_category)
+  end
+end
+

data/spec/amee-data-abstraction/drill_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+describe Drill do
+  it 'knows its options when it is the first choice' do
+    AMEEMocker.new(self,:path=>'transport/car/generic',
+      :selections=>[],
+      :choices=>['diesel','petrol']).drill
+    Transport.begin_calculation[:fuel].send(:choices).should eql ['diesel','petrol']
+  end
+  it 'knows its options when it is a later choice' do
+    AMEEMocker.new(self,:path=>'transport/car/generic',
+      :selections=>[['fuel','diesel']],
+      :choices=>['large','small']).drill
+    t=Transport.begin_calculation
+    t[:fuel].value 'diesel'
+    t[:size].send(:choices).should eql ['large','small']
+  end
+  it 'is enabled iff it is the next choice or has been chosen' do
+    t=Transport.begin_calculation
+    t[:fuel].enabled?.should be_true
+    t[:size].enabled?.should be_false
+    t[:fuel].value 'diesel'
+    t[:fuel].enabled?.should be_true
+    t[:size].enabled?.should be_true
+    t[:size].value 'large'
+    t[:fuel].enabled?.should be_true
+    t[:size].enabled?.should be_true
+  end
+  it 'is valid iff assigned a choice in the choices' do
+    AMEEMocker.new(self,:path=>'transport/car/generic',
+      :selections=>[],
+      :choices=>['diesel','petrol']).drill
+    t=Transport.begin_calculation
+    t[:fuel].value 'diesel'
+    t[:fuel].send(:valid?).should be_true
+    t[:fuel].value 'banana'
+    t[:fuel].send(:valid?).should be_false
+  end
+end

data/spec/amee-data-abstraction/input_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+describe Input do
+ it 'can be given a fixed value' do
+   i=Input.new{fixed 6}
+   i.value.should eql 6
+   i.fixed?.should be_true
+   lambda{i.value 7}.should raise_error Exceptions::FixedValueInterference
+ end
+ it 'raises exception when invalid' do
+   i=Input.new{validation /bark/}
+   i.value 'barking'
+   lambda{i.validate!}.should_not raise_error
+   i.value.should eql 'barking'
+   i.value 'marking'
+   lambda{i.validate!}.should raise_error Exceptions::ChoiceValidation
+   j=Input.new{}
+   j.value 'marking'
+   j.value.should eql 'marking'
+ end
+ it "can accept a numeric symbol validation" do
+   i=Input.new{validation :numeric}
+   i.value 3
+   lambda{i.validate!}.should_not raise_error
+   i.value '3'
+   lambda{i.validate!}.should_not raise_error
+   i.value 'e'
+   lambda{i.validate!}.should raise_error Exceptions::ChoiceValidation
+ end
+ it "can accept a date symbol validation" do
+   i=Input.new{validation :date}
+   i.value Date.today
+   lambda{i.validate!}.should_not raise_error
+   i.value '2011-01-01'
+   lambda{i.validate!}.should_not raise_error
+   i.value 'e'
+   lambda{i.validate!}.should raise_error Exceptions::ChoiceValidation
+ end
+
+ it "can accept a time symbol validation" do
+   i=Input.new{validation :datetime}
+   i.value DateTime.now
+   lambda{i.validate!}.should_not raise_error
+   i.value '2011-01-01 09:00:00'
+   lambda{i.validate!}.should_not raise_error
+   i.value 'e'
+   lambda{i.validate!}.should raise_error Exceptions::ChoiceValidation
+ end
+ it 'can have custom validation message' do
+   i=Input.new{label :woof; validation /bark/; validation_message {"#{value} does not match pattern /bark/"}}
+   i.value 'marking'
+   lambda{i.validate!}.should raise_error Exceptions::ChoiceValidation,"marking does not match pattern /bark/"
+   j=Input.new{}
+   j.value 'marking'
+   j.value.should eql 'marking'
+ end
+ it 'can have default validation message' do
+   i=Input.new{label :woof; validation /bark/}
+   i.value 'barking'
+   lambda{i.validate!}.should_not raise_error
+   i.value.should eql 'barking'
+   i.value 'marking'
+   lambda{i.validate!}.should raise_error Exceptions::ChoiceValidation,"Woof is invalid."
+   j=Input.new{}
+   j.value 'marking'
+   j.value.should eql 'marking'
+ end
+ it 'is always valid if it is fixed' do
+   i=Input.new{fixed 5; validation /7/}
+   lambda{i.validate!}.should_not raise_error
+   i.value.should eql 5
+ end
+ it 'is always disabled if it is fixed' do
+   i=Input.new{fixed 5}
+   i.disabled?.should eql true
+ end
+end

data/spec/amee-data-abstraction/metadatum_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+describe Metadatum do
+ it 'defaults to be a drop-down' do
+   Metadatum.new.drop_down?.should be_true
+ end
+ it 'can have choices specified' do
+   Metadatum.new { choices %w{bob frank}}.choices.should eql ['bob','frank']
+ end
+ it 'validates on choices' do
+   m=Metadatum.new { choices %w{bob frank}}
+   m.value 'bob'
+   m.should be_valid
+   m.value 'mark'
+   m.should_not be_valid
+ end
+end

data/spec/amee-data-abstraction/ongoing_calculation_spec.rb

@@ -0,0 +1,494 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+describe OngoingCalculation do
+  it 'can return set and unset inputs' do
+    d=Electricity.begin_calculation
+    d.inputs.set.labels.should eql [:country]
+    d.inputs.unset.labels.should eql [:energy_used]
+    d[:energy_used].value :somevalue
+    d.inputs.set.labels.should eql [:country,:energy_used]
+    d.inputs.unset.labels.should eql []
+  end
+  it 'can return set and unset terms' do
+    d=Electricity.begin_calculation
+    d.set.labels.should eql [:country]
+    d.unset.labels.should eql [:energy_used,:co2]
+    d[:energy_used].value :somevalue
+    d.set.labels.should eql [:country,:energy_used]
+    d.unset.labels.should eql [:co2]
+  end
+  it 'can return set and unset outputs' do
+    d=Electricity.begin_calculation
+    d.outputs.set.labels.should eql []
+    d.outputs.unset.labels.should eql [:co2]
+    d[:co2].value 5
+    d.outputs.set.labels.should eql [:co2]
+    d.outputs.unset.labels.should eql []
+  end
+  it 'can have values chosen' do
+    AMEEMocker.new(self,:path=>'business/energy/electricity/grid',
+      :selections=>[['country','argentina']],
+      :choices=>[]).drill
+
+    d=Electricity.begin_calculation
+
+    d.inputs.set.values.should eql ['argentina']
+    d.inputs.unset.values.should eql [nil]
+
+    d.choose!(:energy_used=>5.0)
+
+    d.inputs.set.values.should eql ['argentina',5.0]
+    d.inputs.unset.values.should be_empty
+  end
+  it 'knows when it is satisfied' do
+    AMEEMocker.new(self,:path=>'business/energy/electricity/grid',
+      :selections=>[['country','argentina']],
+      :choices=>[]).drill
+    d=Electricity.begin_calculation
+    d.satisfied?.should be_false
+    d.choose!(:energy_used=>5.0)
+    d.satisfied?.should be_true
+  end
+  it 'knows which drills are set, and whether it is satisfied' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'])
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    t=Transport.begin_calculation
+    t.terms.labels.should eql [:fuel,:size,:distance,:co2]
+    t.satisfied?.should be_false
+
+    t.choose!('fuel'=>'diesel')
+    t.inputs.set.labels.should eql [:fuel]
+    t.inputs.unset.labels.should eql [:size,:distance]
+    t.satisfied?.should be_false
+
+    t2=Transport.begin_calculation
+    t2.choose!('fuel'=>'diesel','size'=>'large')
+    t2.inputs.set.labels.should eql [:fuel,:size]
+    t2.inputs.unset.labels.should eql [:distance]
+    t2.satisfied?.should be_false
+
+    t3=Transport.begin_calculation
+    t3.choose!('fuel'=>'diesel','size'=>'large','distance'=>5)
+    t3.inputs.set.labels.should eql [:fuel,:size,:distance]
+    t3.inputs.unset.labels.should eql []
+    t3.satisfied?.should be_true
+  end
+  it 'can do a calculation' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create.get
+    mycalc=Transport.begin_calculation
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5)
+    mycalc.calculate!
+    mycalc.outputs.first.value.should eql :somenumber
+  end
+  it 'does not send general metadata to AMEE' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create.get
+    mycalc=ElectricityAndTransport[:transport].begin_calculation
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5,'department'=>'stuff')
+    mycalc.calculate!
+    mycalc.outputs.first.value.should eql :somenumber
+  end
+
+  #This exception has been removed, to support the case where the persistence module
+  #had a saved calculation from before a configuration file changed. We might want to
+  #do something more sophisticated.
+  #it 'raises exception if choice supplied for invalid term' do
+  #  mycalc=Transport.begin_calculation
+  #  mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+  #    :choices=>['diesel','petrol'],
+  #    :result=>:somenumber,
+  #    :params=>{'distance'=>5})
+  #  mocker.drill
+  #  mocker.select('fuel'=>'diesel')
+  #  mocker.choices=['large','small']
+  #  mocker.drill
+  #  lambda{mycalc.choose!('fuel'=>'diesel','banana'=>'large','distance'=>5)}.
+  #    should raise_exception Exceptions::NoSuchTerm
+  #end
+
+  it 'can be supplied just a UID, and recover PIVs and drill values from AMEE' do
+    mycalc=Transport.begin_calculation
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :result=>:somenumber,
+      :existing=>{'distance'=>5},:choices=>['petrol','diesel'])
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.profile_list.update.get(true)
+    mycalc.choose!(:profile_item_uid=>mocker.uid)
+    mycalc.calculate!
+    mycalc[:fuel].value.should eql 'diesel'
+    mycalc[:distance].value.should eql 5
+    mycalc.outputs.first.value.should eql :somenumber
+  end
+
+  it 'refuses to load values from AMEE which conflict with local drill values' do
+    mycalc=Transport.begin_calculation
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :result=>:somenumber,
+      :existing=>{'distance'=>7},
+      :params=>{'distance'=>7},
+      :choices=>['petrol','diesel'])
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.profile_list.get(true,true).delete
+    existing_uid=mocker.uid
+    mocker.select('size'=>'small')
+    mocker.drill.profile_category.timestamp.create.get
+    mycalc.choose!(:profile_item_uid=>existing_uid,'fuel'=>'diesel','size'=>'small','distance'=>7)
+    mycalc.calculate!
+    mycalc.outputs.first.value.should eql :somenumber
+  end
+
+  it 'lets local profile values replace and update those in amee' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :result=>:somenumber,
+      :choices=>['petrol','diesel'],
+      :params=>{'distance'=>9},
+      :existing=>{'distance'=>5}
+    )
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.update.get(true)
+    mycalc=Transport.begin_calculation
+    mycalc.choose!(:profile_item_uid=>mocker.uid,'fuel'=>'diesel','size'=>'large','distance'=>9)
+    mycalc.calculate!
+    mycalc[:distance].value.should eql 9
+  end
+
+  it 'can be calculated, then recalculated, loading from AMEE the second time' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create
+
+    mocker.existing={'distance'=>5}
+    mocker.params={'distance'=>9}
+    mocker.update.get(true)
+
+    mycalc=Transport.begin_calculation
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5)
+    mycalc.calculate!
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>9)
+    mycalc.calculate!
+    mycalc[:distance].value.should eql 9
+  end
+
+  it 'can be calculated, then change drill, recreating the second time' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create.get(true,true).delete
+
+    mocker.select('size'=>'small')
+    mocker.drill.create.get
+
+    mycalc=Transport.begin_calculation
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5)
+    mycalc.calculate!
+    mycalc.choose!('fuel'=>'diesel','size'=>'small')
+    mycalc.calculate!
+    mycalc[:distance].value.should eql 5
+  end
+
+  it 'memoizes profile information, but not across a pass' do
+    mycalc=Transport.begin_calculation
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :result=>:somenumber,
+      :existing=>{'distance'=>5},:choices=>['petrol','diesel'])
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.profile_list.update.get(true,false,false)
+    mycalc.choose!(:profile_item_uid=>mocker.uid)
+    mycalc.calculate!
+    mycalc.send(:profile_item)
+    mycalc[:fuel].value.should eql 'diesel'
+    mycalc[:distance].value.should eql 5
+    mycalc.outputs.first.value.should eql :somenumber
+  end
+
+  it 'creates profile item with start end dates if appropriate metadata provided' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5,
+                :start_date=>Date.parse("1976-10-19"),
+                :end_date=>Date.parse("2011-1-1")})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create.get
+    myproto=Transport.clone
+    myproto.instance_eval{
+      start_and_end_dates
+    }
+    mycalc=myproto.begin_calculation
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5,'start_date'=>"1976-10-19",'end_date'=>DateTime.parse("2011-1-1"))
+    mycalc.calculate!
+    mycalc.outputs.first.value.should eql :somenumber
+  end
+
+  it 'does not accept start end dates if inappropriate value provided' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5,
+                :end_date=>Date.parse("2011-1-1")})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    myproto=Transport.clone
+    myproto.instance_eval{
+      start_and_end_dates
+    }
+    mycalc=myproto.begin_calculation
+    mycalc.choose('fuel'=>'diesel','size'=>'large','distance'=>5,'start_date'=>"banana",'end_date'=>DateTime.parse("2011-1-1")).should be_false
+    mycalc.invalidity_messages.keys.should eql [:start_date]
+  end
+
+  it 'starts off dirty' do  
+    mycalc=Transport.begin_calculation
+    mycalc.should be_dirty
+  end
+
+  it 'becomes clean when you calculate' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create.get
+    mycalc=Transport.begin_calculation
+    mycalc.should be_dirty
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5)
+    mycalc.calculate!
+    mycalc.should_not be_dirty
+    mycalc.outputs.first.value.should eql :somenumber
+    mycalc.should_not be_dirty
+  end
+
+  it 'becomes dirty again if you reset something after you calculate' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mocker.profile_list.profile_category.timestamp.create.get
+    mycalc=Transport.begin_calculation
+    mycalc.should be_dirty
+    mycalc.choose!('fuel'=>'diesel','size'=>'large','distance'=>5)
+    mycalc.calculate!
+    mycalc.should_not be_dirty
+    mycalc.outputs.first.value.should eql :somenumber
+    mycalc.should_not be_dirty
+    mycalc.choose!('distance'=>7)
+    mycalc.should be_dirty
+  end
+
+  it 'provides error message and raises exception from choose! if choice invalid' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'marge')
+    mocker.choices=[]
+    mocker.drill
+    mycalc=Transport.begin_calculation
+    lambda{mycalc.choose!('fuel'=>'diesel','size'=>'marge','distance'=>5)}.should raise_error Exceptions::ChoiceValidation
+    mycalc.invalidity_messages.keys.should eql [:size]
+  end
+
+  it 'provides error message and returns false from choose if choice invalid' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'marge')
+    mocker.choices=[]
+    mocker.drill
+    mycalc=Transport.begin_calculation
+    mycalc.choose('fuel'=>'diesel','size'=>'marge','distance'=>5).should be_false
+    mycalc.invalidity_messages.keys.should eql [:size]
+  end
+
+  it 'returns true from choose if choices valid' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'large')
+    mocker.choices=[]
+    mocker.drill
+    mycalc=Transport.begin_calculation
+    mycalc.choose('fuel'=>'diesel','size'=>'large','distance'=>5).should be_true
+  end
+
+  it 'can blank individual term attributes with empty string' do
+    myproto=Transport.clone
+    mycalc=myproto.begin_calculation
+    mycalc.choose_without_validation!('fuel'=>'diesel','size'=>'large','distance'=>{:value =>5, :unit=> Unit.km})
+    mycalc['fuel'].value.should eql 'diesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 5
+    mycalc['distance'].unit.symbol.should eql 'km'
+    mycalc.choose_without_validation!('distance'=>{:value =>""})
+    mycalc['fuel'].value.should eql 'diesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql ""
+    mycalc['distance'].unit.symbol.should eql 'km'
+  end
+
+  it 'can blank individual term attributes with nil' do
+    myproto=Transport.clone
+    mycalc=myproto.begin_calculation
+    mycalc.choose_without_validation!('fuel'=>'diesel','size'=>'large','distance'=>{:value =>5, :unit=> Unit.km})
+    mycalc['fuel'].value.should eql 'diesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 5
+    mycalc['distance'].unit.symbol.should eql 'km'
+    mycalc.choose_without_validation!('distance'=>{:value =>nil})
+    mycalc['fuel'].value.should eql 'diesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should be_nil
+    mycalc['distance'].unit.symbol.should eql 'km'
+  end
+
+    it 'can update individual term attributes without nullifying others' do
+    myproto=Transport.clone
+    mycalc=myproto.begin_calculation
+    mycalc.choose_without_validation!('fuel'=>'diesel','size'=>'large','distance'=>{:value =>5, :unit=> Unit.km})
+    mycalc['fuel'].value.should eql 'diesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 5
+    mycalc['distance'].unit.symbol.should eql 'km'
+    mycalc.choose_without_validation!('fuel'=>'biodiesel')
+    mycalc['fuel'].value.should eql 'biodiesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 5
+    mycalc['distance'].unit.symbol.should eql 'km'
+    mycalc.choose_without_validation!('distance'=>{:value =>25})
+    mycalc['fuel'].value.should eql 'biodiesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 25
+    mycalc['distance'].unit.symbol.should eql 'km'
+    mycalc.choose_without_validation!('distance'=>{:unit =>Unit.mi})
+    mycalc['fuel'].value.should eql 'biodiesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 25
+    mycalc['distance'].unit.symbol.should eql 'mi'
+    mycalc.choose_without_validation!('distance'=>{:value=>250,:unit =>Unit.ft})
+    mycalc['fuel'].value.should eql 'biodiesel'
+    mycalc['size'].value.should eql 'large'
+    mycalc['distance'].value.should eql 250
+    mycalc['distance'].unit.symbol.should eql 'ft'
+  end
+
+  it 'clears invalid terms' do
+    mocker=AMEEMocker.new(self,:path=>'transport/car/generic',
+      :choices=>['diesel','petrol'],
+      :result=>:somenumber,
+      :params=>{'distance'=>5})
+    mocker.drill
+    mocker.select('fuel'=>'diesel')
+    mocker.choices=['large','small']
+    mocker.drill
+    mocker.select('size'=>'marge')
+    mocker.choices=[]
+    mocker.drill
+    mycalc=Transport.begin_calculation
+    mycalc.choose('fuel'=>'diesel','size'=>'marge','distance'=>5).should be_false
+    mycalc.invalidity_messages.keys.should eql [:size]
+    mycalc[:size].value.should eql 'marge'
+    mycalc.clear_invalid_terms!
+    mycalc.invalidity_messages.keys.should be_empty
+    mycalc[:size].value.should be_nil
+  end
+end
+