amee-data-persistence 1.0.0

data/lib/amee/db/config.rb

@@ -0,0 +1,54 @@
+# 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.
+
+# :title: Class: AMEE::Db::BaseConfig
+
+require 'singleton'
+
+module AMEE
+  module Db
+    
+    # A singleton class for configuration. Automatically initialised on first use
+    # Use like so:
+    #
+    #   AMEE::Db::Config.instance.store_everything?
+    #
+    # Separated into BaseConfig and Config to allow unit testing of singleton.
+    #
+    class BaseConfig
+    
+      def initialize
+        # Default is metadata
+        @storage_method = load_storage_method || :metadata
+      end
+            
+      attr_reader :storage_method
+
+      def store_metadata?
+        [:metadata, :outputs, :everything].include? storage_method
+      end
+
+      def store_outputs?
+        [:outputs, :everything].include? storage_method
+      end
+
+      def store_everything?
+        [:everything].include? storage_method
+      end
+
+      private
+      
+      def load_storage_method
+        m = YAML.load_file("#{RAILS_ROOT}/config/persistence.yml")['method'].to_sym rescue nil
+        raise "amee-data-persistence: Invalid storage method" unless [:metadata, :outputs, :everything].include? m
+        m
+      end
+
+    end
+    
+    class Config < BaseConfig
+      include Singleton
+    end
+      
+  end
+end

data/lib/amee/db/term.rb

@@ -0,0 +1,72 @@
+# 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.
+
+# :title: Class AMEE::Db::Term
+
+module AMEE
+  module Db
+
+    # This class represents a database record for a calculation term used with
+    # the <i>AMEE:DataAbstraction::OngoingCalculation</i> class. This class stores
+    # the label, value and unit attributes of specific calculation terms, and is
+    # owned by an associated <i>AMEE::Db::Calculation</i> record
+    #
+    # This class is typically used by proxy, via the <tt>#update_calculation!</tt>,
+    # and <tt>#to_hash</tt> methods of the <i>AMEE::Db::Calculation</i> class, and
+    # ultimately called from the <tt>find</tt>, <tt>find_by_type</tt>,
+    # <tt>#save</tt>, <tt>#delete</tt>, and <tt>#get_db_calculation</tt> methods
+    # associated with the <i>AMEE:DataAbstraction::OngoingCalculation</i> class.
+    #
+    class Term < ActiveRecord::Base
+
+      belongs_to :calculation, :class_name => "AMEE::Db::Calculation"
+      validates_presence_of :calculation_id, :label
+      before_save :initialize_units
+      before_save :initialize_value
+
+      # Returns a <i>Hash</i> representation of <tt>self</tt>, e.g.
+      #
+      #   my_term.to_hash       #=> { :value => 1600,
+      #                               :unit => <Quantify::Unit::SI> }
+      #
+      #   my_term.to_hash       #=> { :value => 234.1,
+      #                               :unit => <Quantify::Unit::NonSI>,
+      #                               :per_unit => <Quantify::Unit::SI> }
+      #
+      # This method is called as part of <tt>AMEE::Db::Calculation#to_hash</tt>
+      # in order to provide a full hash representation of a calculation.
+      #
+      def to_hash
+        sub_hash = {}
+        # Float method called on term value in order to initialize
+        # explicitly numeric values as numeric objects.
+        #
+        sub_hash[:value] = AMEE::DataAbstraction::Term.convert_value_to_type(self.value, self.value_type)
+        sub_hash[:unit] = Unit.for(unit) if unit
+        sub_hash[:per_unit] = Unit.for(per_unit) if per_unit
+        { label.to_sym => sub_hash }
+      end
+
+      private
+
+      # Serialize all unit attributes using the string provided by the
+      # <tt>label</tt> attribute of a <i>Quantify::Unit::Base</i> object
+      #
+      def initialize_units
+        if unit
+          self.unit = unit.is_a?(Quantify::Unit::Base) ? unit.label : unit
+        end
+        if per_unit
+          self.per_unit = per_unit.is_a?(Quantify::Unit::Base) ? per_unit.label : per_unit
+        end
+      end
+      
+      def initialize_value
+        unless self.value.nil?
+          self.value_type = self.value.class.to_s
+          self.value      = self.value.to_s
+        end
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,31 @@
+
+# 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'
+require 'amee-data-persistence'
+
+# include the <i>AMEE::DataAbstraction::PersistenceSupport</i> module within the
+# <i>AMEE::DataAbstraction::OngoingCalculation</i> class providing interface
+# methods for managing persistence of calculations.
+#
+::AMEE::DataAbstraction::OngoingCalculation.class_eval { include ::AMEE::DataAbstraction::PersistenceSupport }

data/spec/amee/db/calculation_spec.rb

@@ -0,0 +1,176 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+include AMEE::Db
+
+describe Calculation do
+
+  valid_calculation_attributes = { :profile_item_uid => "G8T8E8SHSH46",
+                                   :calculation_type => :electricity }
+
+  after(:all) do
+    Calculation.delete_all
+  end
+
+  describe "new calculation" do
+
+    before(:all) do
+      @attr = valid_calculation_attributes
+    end
+
+    it "should be valid with profile item uid and calculation type" do
+      @calculation = Calculation.new @attr
+      @calculation.should be_valid
+    end
+
+    it "should be valid without profile item uid" do
+      @calculation = Calculation.new @attr.merge(:profile_item_uid => "")
+      @calculation.should be_valid
+    end
+
+    it "should not be valid without calculation type" do
+      @calculation = Calculation.new @attr.merge(:calculation_type => "")
+      @calculation.should_not be_valid
+    end
+
+    it "should be valid with profile uid additionally specified" do
+      @calculation = Calculation.new @attr.merge(:profile_uid => "GFD8E8SHSH46")
+      @calculation.should be_valid
+    end
+
+    it "should not be valid with non-canonical (short) profile item uid" do
+      @calculation = Calculation.new @attr.merge(:profile_item_uid => "GFD8E8SHS")
+      @calculation.should_not be_valid
+    end
+
+    it "should not be valid with non-canonical (lowercase) profile item uid" do
+      @calculation = Calculation.new @attr.merge(:profile_item_uid => "gfd8e8shsh46")
+      @calculation.should_not be_valid
+    end
+
+    it "should not be valid with non-canonical (short) profile uid" do
+      @calculation = Calculation.new @attr.merge(:profile_uid => "GFD8E8SHS")
+      @calculation.should_not be_valid
+    end
+
+    it "should not be valid with non-canonical (lowercase) profile uid" do
+      @calculation = Calculation.new @attr.merge(:profile_uid => "gfd8e8shsh46")
+      @calculation.should_not be_valid
+    end
+
+    it "should not be valid with non-canonical (invalid characters) profile uid" do
+      @calculation = Calculation.new @attr.merge(:profile_uid => "gfd8&sh*h4.")
+      @calculation.should_not be_valid
+    end
+
+    it "should create a new calculation" do
+      @calculation = Calculation.create @attr
+      @calculation.is_a?(Calculation).should be_true
+    end
+
+    it "should save calculation type as string" do
+      @calculation = Calculation.create! @attr
+      @calculation.reload
+      @calculation.calculation_type.should == 'electricity'
+      @calculation.calculation_type.class.should == String
+      @calculation.type.should == :electricity
+      @calculation.type.class.should == Symbol
+    end
+
+  end
+
+  describe "updating calculation" do
+
+    valid_term_attributes = { :country => {:value => 'Argentina'},
+                              :usage => {:value => 500, :unit => Unit.kWh},
+                              :co2 => {:value => 1234.5, :unit => Unit.kg} }
+
+    before(:each) do
+      @calculation = Calculation.create valid_calculation_attributes
+    end
+
+    it "should update primary attributes" do
+      @calculation.profile_item_uid.should == "G8T8E8SHSH46"
+      @calculation.profile_uid.should == nil
+      @calculation.update_calculation!(:profile_uid => "ASD603SHSHFD", :profile_item_uid => "ASN603DHSREW")
+      @calculation.profile_item_uid.should == "ASN603DHSREW"
+      @calculation.profile_uid.should == "ASD603SHSHFD"
+    end
+
+    it "should not matter which order attributes updated" do
+      @calculation.profile_item_uid.should == "G8T8E8SHSH46"
+      @calculation.update_calculation!(:profile_uid => "ASD603SHSHFD",
+                                       :calculation_type => :energy,
+                                       :profile_item_uid => "ASN603DHSREW")
+      @calculation.profile_item_uid.should == "ASN603DHSREW"
+      @calculation.profile_uid.should == "ASD603SHSHFD"
+      @calculation.type.should == :energy
+      @calculation.update_calculation!(:profile_uid => nil,
+                                       :profile_item_uid => "ASN603DHSREW",
+                                       :calculation_type => :electricity)
+      @calculation.profile_item_uid.should == "ASN603DHSREW"
+      @calculation.profile_uid.should == nil
+      @calculation.type.should == :electricity
+    end
+
+    it "should allow removal of profile item uid" do
+      @calculation.profile_item_uid.should == "G8T8E8SHSH46"
+      @calculation.profile_uid.should == nil
+      @calculation.update_calculation!(:profile_uid => "ASD603SHSHFD", :profile_item_uid => nil)
+      @calculation.profile_item_uid.should == nil
+    end
+
+    it "should update associated terms" do
+      @calculation.to_hash.should == { :profile_item_uid => "G8T8E8SHSH46",
+                                       :profile_uid => nil }
+      @calculation.type.should == :electricity
+      @calculation.update_calculation! valid_term_attributes.merge :calculation_type => :power
+      hash = @calculation.to_hash
+      hash.keys.map!(&:to_s).sort!.should == [ :profile_item_uid, :usage, :co2, :country,
+                                               :profile_uid].map!(&:to_s).sort!
+      hash[:co2][:unit].should be_a Quantify::Unit::SI
+      hash[:co2][:value].should eql 1234.5
+      hash[:co2][:unit].name.should eql 'kilogram'
+      hash[:usage][:unit].should be_a Quantify::Unit::NonSI
+      hash[:usage][:value].should eql 500
+      hash[:usage][:unit].name.should eql 'kilowatt hour'
+      hash[:country][:value].should eql 'Argentina'
+      @calculation.calculation_type.should eql 'power'
+      @calculation.type.should eql :power
+      @calculation.update_calculation! valid_term_attributes.merge :calculation_type => :electricity
+      @calculation.calculation_type.should eql 'electricity'
+      @calculation.type.should eql :electricity
+    end
+
+    it "should update associated terms, removing unspecified terms" do
+      @calculation.to_hash.should == { :profile_item_uid => "G8T8E8SHSH46",
+                                       :profile_uid => nil }
+      @calculation.type.should == :electricity
+      @calculation.update_calculation! valid_term_attributes
+      hash = @calculation.to_hash
+      hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :usage, :co2, :country,
+                                              :profile_uid ].map!(&:to_s).sort!
+      @calculation.type.should == :electricity
+      @calculation.update_calculation! :usage => {:value => 600000, :unit => Unit.kWh}, :country => {:value =>'Argentina'}
+      hash = @calculation.to_hash
+      hash.keys.map!(&:to_s).sort!.should == [ :profile_item_uid, :usage, :country,
+                                              :profile_uid ].map!(&:to_s).sort!
+      hash[:co2].should be_a NilClass
+      hash[:usage][:unit].should be_a Quantify::Unit::NonSI
+      hash[:usage][:value].should == 600000
+      hash[:usage][:unit].name.should == 'kilowatt hour'
+      hash[:country][:value].should == 'Argentina'
+      @calculation.type.should == :electricity
+    end
+
+    it "should find by atttribute" do
+      calc = Calculation.find :first, :conditions => {:calculation_type => 'electricity'}
+      calc.class.should == Calculation
+      calc.type.should == :electricity
+    end
+
+  end
+
+  
+  
+end
+

data/spec/amee/db/config_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe AMEE::Db::Config do
+  
+  describe 'with everything stored' do
+    
+    before :all do
+      flexmock(YAML) do |mock|
+        mock.should_receive(:load_file).and_return('method' => 'everything').once
+      end
+      @config = AMEE::Db::BaseConfig.new
+    end
+      
+    it 'should load method from file' do
+      @config.storage_method.should be(:everything)
+    end
+
+    it 'should correctly answer query methods' do
+      @config.store_metadata?.should be_true
+      @config.store_outputs?.should be_true
+      @config.store_everything?.should be_true
+    end
+    
+  end
+
+  describe 'with metadata stored' do
+    
+    before :all do
+      flexmock(YAML) do |mock|
+        mock.should_receive(:load_file).and_return('method' => 'metadata').once
+      end
+      @config = AMEE::Db::BaseConfig.new
+    end
+      
+    it 'should correctly answer query methods' do
+      @config.store_metadata?.should be_true
+      @config.store_outputs?.should be_false
+      @config.store_everything?.should be_false
+    end
+    
+  end
+
+  describe 'with outputs stored' do
+    
+    before :all do
+      flexmock(YAML) do |mock|
+        mock.should_receive(:load_file).and_return('method' => 'outputs').once
+      end
+      @config = AMEE::Db::BaseConfig.new
+    end
+      
+    it 'should correctly answer query methods' do
+      @config.store_metadata?.should be_true
+      @config.store_outputs?.should be_true
+      @config.store_everything?.should be_false
+    end
+    
+  end
+
+  describe 'with invalid method' do
+    
+    before :all do
+      flexmock(YAML) do |mock|
+        mock.should_receive(:load_file).and_return('method' => 'invalid').once
+      end
+    end
+      
+    it 'should raise an exception on load' do
+      lambda {
+        AMEE::Db::BaseConfig.new
+      }.should raise_error
+    end
+    
+  end
+
+  describe 'with invalid data in file' do
+    
+    before :all do
+      flexmock(YAML) do |mock|
+        mock.should_receive(:load_file).and_return({}).once
+      end
+    end
+      
+    it 'should raise an exception on load' do
+      lambda {
+        AMEE::Db::BaseConfig.new
+      }.should raise_error
+    end
+    
+  end
+
+end

data/spec/amee/db/persistence_support_spec.rb

@@ -0,0 +1,356 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe AMEE::DataAbstraction::OngoingCalculation do
+
+  before(:all) do
+    populate_db
+    initialize_calculation_set
+  end
+
+  after(:all) do
+    AMEE::Db::Calculation.delete_all
+  end
+
+  describe "find" do
+
+    before(:each) do
+      choose_mock
+      yaml_load_mock(:everything)
+      @reference = AMEE::Db::Calculation.find(:first).id
+    end
+
+    it "should create new ongoing calculation from db record" do
+      @db_calculation = AMEE::Db::Calculation.find :first
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.initialize_from_db_record @db_calculation
+      @ongoing_calculation.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+      @ongoing_calculation.label.should == :electricity
+      @ongoing_calculation.profile_item_uid.should == "J38DY57SK591"
+      @ongoing_calculation.profile_uid.should be_nil
+      hash = @ongoing_calculation.to_hash
+      hash[:co2][:value].should == 1200
+      hash[:country][:value].should == 'Argentina'
+      hash[:usage][:value].should == 6000
+      hash[:profile_item_uid].should == "J38DY57SK591"
+      hash[:profile_uid].should be_nil
+    end
+
+    it "should create new ongoing calculation from db record with find" do
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+      @ongoing_calculation.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+      @ongoing_calculation.label.should == :electricity
+      @ongoing_calculation.profile_item_uid.should == "J38DY57SK591"
+      @ongoing_calculation.profile_uid.should be_nil
+      hash = @ongoing_calculation.to_hash
+      hash[:co2][:value].should == 1200
+      hash[:country][:value].should == 'Argentina'
+      hash[:usage][:value].should == 6000
+      hash[:profile_item_uid].should == "J38DY57SK591"
+      hash[:profile_uid].should be_nil
+    end
+  
+    it "should create new ongoing calculation from db record with find and calculation type" do
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first, :conditions => {:calculation_type => 'electricity'}
+      @ongoing_calculation.label.should == :electricity
+      @ongoing_calculation.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+      @ongoing_calculation.profile_item_uid.should == "J38DY57SK591"
+      @ongoing_calculation.profile_uid.should be_nil
+      hash = @ongoing_calculation.to_hash
+      hash[:co2][:value].should == 1200
+      hash[:country][:value].should == 'Argentina'
+      hash[:usage][:value].should == 6000
+      hash[:profile_item_uid].should == "J38DY57SK591"
+      hash[:profile_uid].should be_nil
+    end
+
+    it "should create new ongoing calculation from db record with find and profile item uid" do
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first, :conditions => {:profile_item_uid => "K588DH47SMN5"}
+      @ongoing_calculation.label.should == :electricity
+      @ongoing_calculation.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+      @ongoing_calculation.profile_item_uid.should == "K588DH47SMN5"
+      @ongoing_calculation.profile_uid.should == "H9KJ49FKIWO5"
+      hash = @ongoing_calculation.to_hash
+      hash[:co2][:value].should == 1.2
+      hash[:country][:value].should == 'Argentina'
+      hash[:usage][:value].should == 12345
+      hash[:profile_item_uid].should == "K588DH47SMN5"
+      hash[:profile_uid].should == "H9KJ49FKIWO5"
+    end
+  
+    it "should create multiple new ongoing calculations from db record with find" do
+      @ongoing_calculations = AMEE::DataAbstraction::OngoingCalculation.find :all
+      @ongoing_calculations.class.should == AMEE::DataAbstraction::CalculationCollection
+      @ongoing_calculations.each do |on_calc|
+        on_calc.label.should == :electricity
+        on_calc.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+        on_calc.profile_item_uid.should_not be_nil
+        hash = on_calc.to_hash
+        hash[:co2][:value].should_not be_nil
+        hash[:country][:value].should == 'Argentina'
+        hash[:usage][:value].should_not be_nil
+      end
+    end
+
+    it "should create new ongoing calculation from db record with #find_by_type" do
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find_by_type :first, :electricity
+      @ongoing_calculation.label.should == :electricity
+      @ongoing_calculation.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+      @ongoing_calculation.profile_item_uid.should == "J38DY57SK591"
+      @ongoing_calculation.profile_uid.should == nil
+      hash = @ongoing_calculation.to_hash
+      hash[:co2][:value].should == 1200
+      hash[:country][:value].should == 'Argentina'
+      hash[:usage][:value].should == 6000
+      hash[:profile_item_uid].should == "J38DY57SK591"
+      hash[:profile_uid].should == nil
+    end
+
+    it "should create multiple new ongoing calculations from db record with #find_by_type" do
+      @ongoing_calculations = AMEE::DataAbstraction::OngoingCalculation.find_by_type :all, :electricity
+      @ongoing_calculations.class.should == AMEE::DataAbstraction::CalculationCollection
+      @ongoing_calculations.each do |on_calc|
+        on_calc.label.should == :electricity
+        on_calc.is_a?(AMEE::DataAbstraction::OngoingCalculation).should be_true
+        on_calc.profile_item_uid.should_not be_nil
+        hash = on_calc.to_hash
+        hash[:co2][:value].should_not be_nil
+        hash[:country][:value].should == 'Argentina'
+        hash[:usage][:value].should_not be_nil
+      end
+    end
+
+    it "should instantiate record at ongoing calc #db_calculation attribute" do
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+      @ongoing_calculation.label.should == :electricity
+      @ongoing_calculation.to_hash[:co2][:value].should == 1200
+      @ongoing_calculation.db_calculation.is_a?(AMEE::Db::Calculation).should be_true
+      @ongoing_calculation.db_calculation.id.should == @reference
+    end
+
+    it "should find assocaited db instance by id" do
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find @reference
+      @ongoing_calculation.id.should == @reference
+    end
+
+
+    it "should give nil id, if not saved" do
+      Calculations[:electricity].begin_calculation.db_calculation.should be_nil
+      Calculations[:electricity].begin_calculation.id.should be_nil
+    end
+  end
+
+  describe "when storage method is :everything" do
+
+    before(:each) do
+      choose_mock
+      yaml_load_mock(:everything)
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+    end
+
+    it "should find storage method" do
+      AMEE::DataAbstraction::OngoingCalculation.storage_method.should == :everything
+    end
+
+    it "should start off dirty" do
+      @ongoing_calculation.should be_dirty
+    end
+
+    it "should establish whether inputs to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_inputs?.should be_true
+    end
+
+    it "should establish whether outputs to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_outputs?.should be_true
+    end
+
+    it "should establish whether metadata to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_metadata?.should be_true
+    end
+
+    it "should return array of terms for storing which includes all terms" do
+      @ongoing_calculation.stored_terms.should == @ongoing_calculation.terms
+    end
+
+    it "should return hash with all terms" do
+      hash = @ongoing_calculation.to_hash
+      hash.is_a?(Hash).should be_true
+      hash.should == @ongoing_calculation.to_hash(:full)
+      hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, :calculation_type,
+                                              :co2, :usage, :country ].map!(&:to_s).sort!
+    end
+
+    it "should save all terms" do
+      record = @ongoing_calculation.db_calculation
+      # show that db record has values
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, :co2,
+                                                        :usage, :country ].map!(&:to_s).sort!
+      record.to_hash[:co2][:value].should == 1200
+      record.to_hash[:usage][:value].should == 6000
+      # wipe terms from db record by updating with nothing
+      record.update_calculation!(options={})
+      # show that db record contains no terms
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid ].map!(&:to_s).sort!
+      # show that by saving ongoing calculation, db record has terms
+      @ongoing_calculation.save
+      record = @ongoing_calculation.db_calculation
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, :co2,
+                                                        :usage, :country ].map!(&:to_s).sort!
+      record.to_hash[:co2][:value].should == 1200
+      record.to_hash[:usage][:value].should == 6000
+    end
+
+  end
+
+  describe "when storage method is :metadata" do
+
+    before(:each) do
+      choose_mock
+      yaml_load_mock(:metadata)
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+    end
+
+    it "should find storage method" do
+      AMEE::DataAbstraction::OngoingCalculation.storage_method.should == :metadata
+    end
+
+    it "should establish whether inputs to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_inputs?.should be_false
+    end
+
+    it "should establish whether outputs to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_outputs?.should be_false
+    end
+
+    it "should establish whether metadata to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_metadata?.should be_true
+    end
+
+    it "should start off dirty" do
+      @ongoing_calculation.should be_dirty
+    end
+
+    it "should return array of terms for storing which includes only metadata" do
+      @ongoing_calculation.stored_terms.should_not == @ongoing_calculation.terms
+    end
+
+    it "should return hash with only metadata terms" do
+      hash = @ongoing_calculation.to_hash
+      hash.is_a?(Hash).should be_true
+      hash.should_not == @ongoing_calculation.to_hash(:full)
+      hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid,
+                                              :calculation_type ].map!(&:to_s).sort!
+    end
+
+    it "should save only metadata terms" do
+      record = @ongoing_calculation.db_calculation
+      # show that db record has values
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, :co2,
+                                                        :usage, :country ].map!(&:to_s).sort!
+      record.to_hash[:co2][:value].should == 1200
+      record.to_hash[:usage][:value].should == 6000
+      # show that db record contains no terms after save
+      @ongoing_calculation.save
+      record = @ongoing_calculation.db_calculation
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid ].map!(&:to_s).sort!
+      record.to_hash[:co2].should == nil
+      record.to_hash[:usage].should == nil
+    end
+
+  end
+
+  describe "when storage method is :outputs" do
+
+    before(:each) do
+      choose_mock
+      yaml_load_mock(:outputs)
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+    end
+
+    it "should find storage method" do
+      AMEE::DataAbstraction::OngoingCalculation.storage_method.should == :outputs
+    end
+
+    it "should establish whether inputs to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_inputs?.should be_false
+    end
+
+    it "should establish whether outputs to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_outputs?.should be_true
+    end
+
+    it "should establish whether metadata to be stored" do
+      AMEE::DataAbstraction::OngoingCalculation.store_metadata?.should be_true
+    end
+
+    it "should start off dirty" do
+      @ongoing_calculation.should be_dirty
+    end
+
+    it "should return array of terms for storing which includes only outputs and metadata" do
+      @ongoing_calculation.stored_terms.should_not == @ongoing_calculation.terms
+    end
+
+    it "should return hash with only output and metadata terms" do
+      hash = @ongoing_calculation.to_hash
+      hash.is_a?(Hash).should be_true
+      hash.should_not == @ongoing_calculation.to_hash(:full)
+      hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, 
+                                              :calculation_type, :co2 ].map!(&:to_s).sort!
+    end
+
+    it "should save only output terms" do
+      record = @ongoing_calculation.db_calculation
+      # show that db record has all values
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, :co2,
+                                                        :usage, :country ].map!(&:to_s).sort!
+      record.to_hash[:co2][:value].should == 1200
+      record.to_hash[:usage][:value].should == 6000
+      # show that db record contains only output terms after save
+      @ongoing_calculation.save
+      record = @ongoing_calculation.db_calculation
+      record.to_hash.keys.map!(&:to_s).sort!.should == [:profile_item_uid, :profile_uid, :co2 ].map!(&:to_s).sort!
+      record.to_hash[:co2][:value].should == 1200
+      record.to_hash[:usage].should == nil
+    end
+
+  end
+
+  describe "saving" do
+    
+    before :each do
+      choose_mock
+      yaml_load_mock(:outputs)
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+    end
+    
+    it "should return true if successful" do
+      @ongoing_calculation.save.should eql true
+    end
+    
+    it "should return false if unsuccessful" do
+      # Mock to make save fail
+      flexmock(@ongoing_calculation.db_calculation).should_receive(:save!).and_raise(ActiveRecord::RecordNotSaved)
+      # Saving should now return false, propogating errors from AR::Base
+      @ongoing_calculation.save.should eql false
+    end
+    
+  end
+
+  describe "deleting calculation" do
+
+    before(:all) do
+      choose_mock
+      delete_mock
+      @ongoing_calculation = AMEE::DataAbstraction::OngoingCalculation.find :first
+    end
+
+    it "should remove record from db" do
+      db_reference = @ongoing_calculation.db_calculation.id
+      item_uid = @ongoing_calculation.send :profile_item_uid
+      @ongoing_calculation.delete
+      @ongoing_calculation.db_calculation.should be_nil
+      AMEE::Db::Calculation.find_by_profile_item_uid(item_uid).should be_nil
+      lambda{AMEE::Db::Calculation.find(db_reference)}.should raise_error
+    end
+  end
+
+end