amee-data-abstraction 1.0.0

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

@@ -0,0 +1,39 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+describe Profile do
+ it 'defaults to be a text-box' do
+   i=Profile.new
+   i.text_box?.should be_true
+ end
+ it 'can know if it belongs to a particular usage' do
+    mocker=AMEEMocker.new self,:path=>'transport/car/generic'
+    mocker.item_value_definitions.
+      item_definition.data_category.
+    item_value_definition('distance',['someusage'],['someotherusage'])
+    t=Transport.clone
+    t[:distance].compulsory?('someusage').should eql true
+    t[:distance].compulsory?('someotherusage').should eql false
+    t[:distance].optional?('someotherusage').should eql true
+    t[:distance].optional?('someusage').should eql false
+  end
+  it 'can have choices' do
+    i=Profile.new{label :one; choices ['a','b']}
+    i.choices.should eql ['a','b']
+    i.interface.should eql :drop_down
+  end
+  it 'must have a chosen choice if it has a choice' do
+    i=Profile.new{label :one; choices ['a','b']}
+    i.choices.should eql ['a','b']
+    i.value 'a'
+    i.should be_valid
+    i.value 'c'
+    i.should_not be_valid
+  end
+  it 'doesn''t have to have choices' do
+    i=Profile.new{label :one}
+    i.choices.should be_nil
+    i.interface.should eql :text_box
+    i.value 'mark'
+    i.should be_valid
+  end
+end

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

@@ -0,0 +1,256 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+class PrototypeCalculation
+  def call_me
+    #stub, because flexmock doesn't work for new instances during constructor
+    @@called=true
+  end
+  cattr_accessor :called
+end
+describe PrototypeCalculation do
+  it 'can create an instance' do
+    Transport.should be_a PrototypeCalculation
+  end
+  it 'can be initialized with a DSL block' do
+    PrototypeCalculation.new {call_me}
+    PrototypeCalculation.called.should be_true
+  end
+  it 'can make a drill in the DSL block' do
+    pc=PrototypeCalculation.new {drill{label :alpha}}
+    pc[:alpha].should be_a Drill
+  end
+  it 'can''t make a DSL block term without a label' do
+    lambda{
+      pc=PrototypeCalculation.new {drill}
+    }.should raise_error Exceptions::DSL
+  end
+  it 'can make a profile item value in the DSL block' do
+    pc=PrototypeCalculation.new {profile{label :alpha}}
+    pc[:alpha].should be_a Profile
+  end
+  it 'can make an output in the DSL block' do
+    pc=PrototypeCalculation.new {output{label :alpha}}
+    pc[:alpha].should be_a Output
+  end
+  it 'can construct an ongoing calculation' do
+    Transport.begin_calculation.should be_a OngoingCalculation
+  end
+  it 'should make the terms of the ongoing calculation be their own instances' do
+    oc=Transport.begin_calculation
+    oc[:distance].value :somevalue
+    oc[:distance].value.should eql :somevalue
+    Transport[:distance].value.should be_nil
+  end
+  it 'should copy name, path, label when cloning ongoing' do
+    [:path,:name,:label].each do |property|
+      Transport.begin_calculation.send(property).should eql Transport.send(property)
+    end
+  end
+  it 'can autogenerate drill terms for itself, based on talking to amee' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.itemdef_drills ['first','second','third']
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',[],[],[],nil,nil,nil,false,true).
+      item_value_definition('second',[],[],[],nil,nil,nil,false,true).
+      item_value_definition('third',[],[],[],nil,nil,nil,false,true)
+    pc=PrototypeCalculation.new {path '/something'; all_drills}
+    pc.drills.labels.should eql [:first,:second,:third]
+    pc.drills.names.should eql ['First','Second','Third']
+  end
+  it 'can autogenerate profile terms for itself' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',[],[],[],[],nil,nil,true,false,nil,"DOUBLE").
+      item_value_definition('second',[],[],[],[],:kg,nil,true,false,nil,"DOUBLE").
+      item_value_definition('third',[],[],[],[],nil,nil,true,false,nil,"DOUBLE")
+    pc=PrototypeCalculation.new {path '/something'; all_profiles}
+    pc.profiles.labels.should eql [:first,:second,:third]
+    pc.profiles.default_units.first.should be_nil
+    pc.profiles.default_units.compact.first.should be_a Quantify::Unit::Base
+  end
+  it 'can autogenerate profile terms for itself, based on a usage' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],[],[],nil,nil,true,false,nil,"DOUBLE").
+      item_value_definition('second',['bybob'],[],[],[],:MBTU,:year,true,false,nil,"DOUBLE").
+      item_value_definition('third',[],[],['bybob'],[],nil,nil,true,false,nil,"DOUBLE")
+    pc=PrototypeCalculation.new {path '/something'; profiles_from_usage('bybob')}
+    pc.profiles.labels.should eql [:first,:second]
+    pc.profiles.default_units.first.should be_nil
+    pc.profiles.default_units.compact.first.symbol.should eql 'MBTU'
+    pc.profiles.default_per_units.compact.first.symbol.should eql 'yr'
+  end
+  it 'can generate profile terms with choices' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],[],['a','b'],nil,nil,true,false,nil,"DOUBLE").
+      item_value_definition('second',['bybob'],[],[],[],nil,nil,true,false,nil,"DOUBLE").
+      item_value_definition('third',[],[],['bybob'],[],nil,nil,true,false,nil,"DOUBLE")
+    pc=PrototypeCalculation.new {path '/something'; profiles_from_usage('bybob')}
+    pc[:first].choices.should eql ['a','b']
+    pc[:first].interface.should eql :drop_down
+    pc[:second].choices.should be_empty
+    pc[:second].interface.should eql :text_box
+  end
+  it 'can generate profile terms with default values' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],[],['a','b'],nil,nil,true,false,"commercial","TEXT").
+      item_value_definition('second',['bybob'],[],[],[],nil,nil,true,false,1200,"INTEGER").
+      item_value_definition('third',['bybob'],[],[],[],nil,nil,true,false,nil,"DOUBLE")
+    pc=PrototypeCalculation.new {path '/something'; profiles_from_usage('bybob')}
+    pc[:first].value.should eql "commercial"
+    pc[:second].value.should eql 1200
+    pc[:third].value.should be_nil
+  end
+  it 'can generate profile terms with annotations' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],[],['a','b'],nil,nil,true,false,nil,"TEXT","Specify a number of something").
+      item_value_definition('second',['bybob'],[],[],[],nil,nil,true,false,nil,"TEXT","Specify a number of something else").
+      item_value_definition('third',['bybob'],[],[],[],nil,nil,true,false,nil,"TEXT")
+    pc=PrototypeCalculation.new {path '/something'; profiles_from_usage('bybob')}
+    pc[:first].note.should eql "Specify a number of something"
+    pc[:second].note.should eql "Specify a number of something else"
+    pc[:third].note.should be_nil
+  end
+  it 'can generate profile terms with types' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],[],['a','b'],nil,nil,true,false,nil,"DECIMAL").
+      item_value_definition('second',['bybob'],[],[],[],nil,nil,true,false,nil,"TEXT").
+      item_value_definition('third',['bybob'],[],[],[],nil,nil,true,false,'true',"BOOLEAN")
+    pc=PrototypeCalculation.new {path '/something'; profiles_from_usage('bybob')}
+    pc[:first].type.should eql "decimal"
+    pc[:second].type.should eql "text"
+    pc[:third].type.should eql "boolean"
+    pc[:third].value.should be_true
+  end
+  it 'can select terms by usage with a longer list' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      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")
+    pc=PrototypeCalculation.new {path '/something'; all_profiles ; fixed_usage 'bybob'}
+    pc.profiles.in_use.labels.should eql [:first,:second]
+    pc.profiles.out_of_use.labels.should eql [:third]
+    pc.fixed_usage 'byfrank'
+    pc.profiles.out_of_use.labels.should eql [:first,:second]
+    pc.profiles.in_use.labels.should eql [:third]
+  end
+  it 'can generate itself with dynamic usage dropdown' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob'],[],'byfrank',[],:kg,:mi,true,false,nil,"TEXT").
+      item_value_definition('second',['bybob'],[],'byfrank',[],:km,nil,true,false,nil,"TEXT").
+      item_value_definition('third',['byfrank'],[],['bybob'],[],:lb,:h,true,false,nil,"TEXT")
+    pc=PrototypeCalculation.new {path '/something'; usage{ value 'bybob'}}
+    pc.profiles.labels.should eql [:first,:second,:third]
+    pc.profiles.visible.labels.should eql [:first,:second]
+    pc.terms.labels.should eql [:usage,:first,:second,:third]
+    pc.terms.default_units.first.should be_nil
+    pc.terms.default_units[1].should be_a Quantify::Unit::Base
+    pc.terms.default_units[1].name.should eql 'kilogram'
+    pc.terms.default_per_units.first.should be_nil
+    pc.terms.default_per_units[1].should be_a Quantify::Unit::Base
+    pc.terms.default_per_units[1].name.should eql 'mile'
+    pc.terms.default_per_units[2].should be_nil
+  end
+  it 'can generate itself with outputs' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.return_value_definitions.
+      item_definition.data_category.
+      return_value_definition('first',:kg,:mi).
+      return_value_definition('second',:km).
+      return_value_definition('third')
+    pc=PrototypeCalculation.new {path '/something'; all_outputs}
+    pc.outputs.labels.should eql [:first,:second,:third]
+    pc.terms.default_units.first.should be_a Quantify::Unit::Base
+    pc.terms.default_units.first.name.should eql 'kilogram'
+    pc.terms.default_per_units.first.should be_a Quantify::Unit::Base
+    pc.terms.default_per_units.first.name.should eql 'mile'
+    pc.terms.default_units[2].should be_nil
+  end
+
+  it 'can generate itself with everything' do
+    mocker=AMEEMocker.new(self,:path=>'something')
+    mocker.itemdef_drills ['first','second','third']
+    mocker.return_value_definitions.
+      item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('first',['bybob','byfrank'],[],[],[],nil,nil,false,true,nil,"TEXT").
+      item_value_definition('second',['bybob','byfrank'],[],[],[],nil,nil,false,true,nil,"TEXT").
+      item_value_definition('third',['bybob','byfrank'],[],[],[],nil,nil,false,true,nil,"TEXT").
+      item_value_definition('fourth',['bybob'],[],'byfrank',[],nil,nil,true,false,nil,"TEXT").
+      item_value_definition('fifth',['bybob'],[],'byfrank',[],:lb,nil,true,false,nil,"TEXT").
+      item_value_definition('sixth',['byfrank'],[],['bybob'],[],nil,nil,true,false,nil,"TEXT").
+      return_value_definition('seventh').
+      return_value_definition('eighth').
+      return_value_definition('ninth',:mi,:h)
+    pc=PrototypeCalculation.new {
+      path '/something';
+      terms_from_amee_dynamic_usage 'bybob'}
+    pc.terms.labels.should eql [:usage,
+      :first,:second,:third,
+      :fourth,:fifth,:sixth,
+      :seventh,:eighth,:ninth
+    ]
+    pc.terms.names.should eql ['Usage',
+      'First','Second','Third',
+      'Fourth','Fifth','Sixth',
+      'Seventh','Eighth','Ninth'
+    ]
+    pc.terms.visible.labels.should eql  [:usage,
+      :first,:second,:third,
+      :fourth,:fifth,
+      :seventh,:eighth,:ninth
+    ]
+    pc.terms.default_units.compact.first.should be_a Quantify::Unit::Base
+    pc.terms.default_units.compact.map(&:name).should include 'pound'
+    pc.terms.default_units.compact.map(&:name).should include 'mile'
+    pc.terms.default_per_units.compact.first.should be_a Quantify::Unit::Base
+    pc.terms.default_per_units.compact.map(&:name).should include 'hour'
+  end
+  it 'transfers memoised amee information to constructed ongoing calculations' do
+    t=Transport.clone
+    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.begin_calculation.send(:amee_data_category)
+  end
+  it 'can auto-create start and end date metadata' do
+    t=Transport.clone
+    t.instance_eval{
+      start_and_end_dates
+    }
+    t.metadata.labels.should eql [:start_date,:end_date]
+    t[:start_date].interface.should eql :date
+    t[:start_date].date?.should be_true
+    t.date.labels.should eql [:start_date,:end_date]
+  end
+  it 'can correct a dodgy term' do
+    pc=PrototypeCalculation.new {
+      metadatum{ label :frank }
+      correcting(:frank) {name "Bob"}
+    }
+    pc[:frank].name.should eql "Bob"
+  end
+  it 'lets corrections on missing terms go' do
+    lambda{pc=PrototypeCalculation.new {
+      metadatum{ label :sid }
+      correcting(:frank) {name "Bob"}
+    }}.should_not raise_error
+  end
+end
+

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

@@ -0,0 +1,385 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+class Term
+  def call_me
+    #stub, because flexmock doesn't work for new instances during constructor
+    @@called=true
+  end
+  cattr_accessor :called
+end
+
+describe Term do
+  it 'can be initialized via DSL block' do
+    Term.new {call_me}
+    Term.called.should be_true
+  end
+
+  it "has label" do
+    Term.new {label :hello}.label.should eql :hello
+  end
+
+  it "has name" do
+    Term.new {name :hello}.name.should eql :hello
+  end
+
+  it "has path" do
+    Term.new {path :hello}.path.should eql :hello
+  end
+
+  it "has note" do
+    Term.new {note 'hello'}.note.should eql 'hello'
+  end
+
+  it 'has parent' do
+    Transport[:distance].parent.should eql Transport
+  end
+  it "has name defaulting to label" do
+    Term.new {label :hello}.name.should eql 'Hello'
+    Term.new {label :hello ; name 'goodbye'}.name.should eql 'goodbye'
+    Term.new {name 'goodbye' ; label :hello }.name.should eql 'goodbye'
+  end
+  it 'has path defaulting to label' do
+    Term.new {label :hello}.path.should eql 'hello'
+    Term.new {label :hello ; path 'goodbye'}.path.should eql 'goodbye'
+    Term.new {path 'goodbye' ; label :hello }.path.should eql 'goodbye'
+  end
+  it 'has value' do
+    Term.new {value :hello}.value.should eql :hello
+  end
+  it 'knows if it is set' do
+    Term.new {value :hello}.set?.should be_true
+    Term.new.set?.should be_false
+  end
+  it 'has interface' do
+    Term.new {interface :text_box}.interface.should eql :text_box
+  end
+  it 'raises exception on invalid interface' do
+    lambda{Term.new {interface :bobby}}.should raise_error Exceptions::InvalidInterface
+  end
+  it 'knows what it''s interface is' do
+    Term.new {interface :text_box}.text_box?.should be_true
+    Term.new {interface :text_box}.drop_down?.should be_false
+    Term.new {interface :drop_down}.text_box?.should be_false
+    Term.new {interface :drop_down}.drop_down?.should be_true
+  end
+  it 'can be enabled or disabled' do
+    t=Term.new
+    t.enabled?.should be_true
+    t.disabled?.should be_false
+    t.disable!
+    t.enabled?.should be_false
+    t.disabled?.should be_true
+    t.enable!
+    t.enabled?.should be_true
+    t.disabled?.should be_false
+  end
+  it 'can be visible or invisible' do
+    t=Term.new
+    t.visible?.should be_true
+    t.hidden?.should be_false
+    t.hide!
+    t.visible?.should be_false
+    t.hidden?.should be_true
+    t.show!
+    t.visible?.should be_true
+    t.hidden?.should be_false
+  end
+  it 'knows which terms come before or after it' do
+    Transport.terms.
+      select{|x|x.before?(:distance)}.map(&:label).
+      should eql [:fuel,:size]
+    Transport.terms.
+      select{|x|x.after?(:distance)}.map(&:label).
+      should eql [:co2]
+  end
+
+  it "should respond to unit methods" do
+    Term.new.methods.should include "unit","per_unit","default_unit","default_per_unit",
+                                    "alternative_units","alternative_per_units"
+  end
+
+  it "has no default unit if none declared" do
+    Term.new {path :hello}.default_unit.should be_nil
+    Term.new {path :hello}.default_per_unit.should be_nil
+    Term.new {path :hello}.unit.should be_nil
+    Term.new {path :hello}.per_unit.should be_nil
+  end
+
+  it "has default unit if specified" do
+    Term.new {path :hello; default_unit :kg}.default_unit.name.should == 'kilogram'
+    Term.new {path :hello; default_per_unit :kWh}.default_per_unit.pluralized_name.should == 'kilowatt hours'
+    Term.new {path :hello; default_unit :kg}.default_unit.should be_a Quantify::Unit::SI
+  end
+
+  it "has current unit defaulting to default unit if none specified" do
+    Term.new {path :hello; default_unit :kg}.unit.name.should == 'kilogram'
+    Term.new {path :hello; default_per_unit :kWh}.per_unit.pluralized_name.should == 'kilowatt hours'
+    Term.new {path :hello; default_unit :kg}.unit.should be_a Quantify::Unit::SI
+  end
+
+  it "should have no alternative units if none specified and no default" do
+    term = Term.new {path :hello}
+    term.default_unit.should be_nil
+    term.unit.should be_nil
+    term.default_per_unit.should be_nil
+    term.per_unit.should be_nil
+    term.alternative_units.should be_nil
+    term.alternative_per_units.should be_nil
+  end
+
+  it "has default unit alternatives if none specified" do
+    term = Term.new {path :hello; default_unit :kg; default_per_unit :kWh}
+    units = term.alternative_units.map(&:name)
+    units.should include "gigagram", "pound", "tonne"
+    per_units = term.alternative_per_units.map(&:name)
+    per_units.should include "joule", "british thermal unit", "megawatt hour"
+  end
+
+  it "has limited set of alternative units if specified" do
+    term = Term.new {path :hello; default_unit :kg; alternative_units :t, :ton_us, :lb}
+    units = term.alternative_units.map(&:name)
+    units.should include "tonne", "pound", "short ton"
+    units.should_not include "gigagram", "ounce", "gram"
+  end
+
+  it "should raise error when specifying incompatible alternative units" do
+    lambda{Term.new {path :hello; default_unit :kg; alternative_units :kWh, :km}}.should raise_error
+  end
+
+  it "should make a clone" do
+    term = Term.new {path :hello; default_unit :kg; alternative_units :t, :ton_us, :lb}
+    term.path.should eql :hello
+    term.default_unit.should be_a Quantify::Unit::Base
+    original_unit_instance = term.default_unit
+    term.default_unit.symbol.should eql 'kg'
+    new_term = term.clone
+    new_term.path.should eql :hello
+    new_term.default_unit.should be_a Quantify::Unit::Base
+    new_term.default_unit.symbol.should eql 'kg'
+    new_unit_instance = new_term.default_unit
+    original_unit_instance.should_not eql new_unit_instance
+  end
+
+  it "should represent term as string with unit symbol if no argument provided" do
+    Term.new {path :hello; value 12; default_unit :kg}.to_s.should == '12 kg'
+    Term.new {path :hello; value 12; default_unit :kg; per_unit :h}.to_s.should == '12 kg h^-1'
+    Term.new {path :hello; value 12; per_unit :h}.to_s.should == '12 h^-1'
+  end
+
+  it "should represent term as string with unit label" do
+    Term.new {path :hello; value 12; default_unit :kg}.to_s(:label).should == '12 kg'
+    Term.new {path :hello; value 12; default_unit :kg; per_unit :h}.to_s(:label).should == '12 kg/h'
+    Term.new {path :hello; value 12; per_unit :h}.to_s(:label).should == '12 h^-1'
+  end
+
+  it "should represent term as string with unit name" do
+    Term.new {path :hello; value 12; default_unit :kg}.to_s(:name).should == '12 kilogram'
+    Term.new {path :hello; value 12; default_unit :kg; per_unit :h}.to_s(:name).should == '12 kilogram per hour'
+    Term.new {path :hello; value 12; per_unit :h}.to_s(:name).should == '12 per hour'
+  end
+
+  it "should represent term as string with unit pluralized name" do
+    Term.new {path :hello; value 12; default_unit :kg}.to_s(:pluralized_name).should == '12 kilograms'
+    Term.new {path :hello; value 12; default_unit :kg; per_unit :h}.to_s(:pluralized_name).should == '12 kilograms per hour'
+    Term.new {path :hello; value 12; per_unit :h}.to_s(:pluralized_name).should == '12 per hour'
+  end
+
+  it "should be recognised as numeric" do
+    Term.new {path :hello; value 12; default_unit :kg}.has_numeric_value?.should be_true
+  end
+
+  it "should be recognised as non numeric" do
+    Term.new {path :hello; value 'bob'; default_unit :kg}.has_numeric_value?.should be_false
+  end
+  
+  it "should convert the input to a String if the type is specified as such" do
+    Term.new {type :string; value 54}.value.should == "54"
+  end
+  
+  it "should convert the input to a Fixnum if the type is specified as such" do
+    Term.new {type :fixnum; value '54'}.value.should == 54
+  end
+  
+  it "should convert the input to a Float if the type is specified as such" do
+    Term.new {type :float; value '54'}.value.should == 54.0
+  end
+  
+  it "should convert the input to a Date if the type is specified as such" do
+    Term.new {type :date; value '2011-01-01'}.value.should == Date.parse("2011-01-01")
+  end
+  
+  it "should convert the input to a Time if the type is specified as such" do
+    Term.new {type :time; value "2011-01-01 10:00:00"}.value.should == Time.parse("2011-01-01 10:00:00")
+  end
+  
+  it "should convert the input to a DateTime if the type is specified as such" do
+    now = DateTime.now
+    Term.new {type :datetime; value now.to_s}.value.should === now
+  end
+  
+  it "should store the pre cast value" do
+    term = Term.new {type :float; value '54'}
+    term.value.should == 54.0
+    term.value_before_cast.should == "54"
+  end
+
+    it "should return self if no unit or per unit attribute" do
+    @term = Term.new { value 20 }
+    @term.unit.should be_nil
+    @term.per_unit.should be_nil
+    @term.value.should eql 20
+    new_term = @term.convert_unit(:unit => :t)
+    new_term.should === @term
+    new_term.value.should eql 20
+    new_term.unit.should be_nil
+    new_term.per_unit.should be_nil
+  end
+
+  it "should return self if not a numeric unit" do
+    @term = Term.new { value 'plane'; unit :kg }
+    @term.unit.label.should eql 'kg'
+    @term.value.should eql 'plane'
+    new_term = @term.convert_unit(:unit => :t)
+    new_term.should === @term
+  end
+
+  it "should convert unit" do
+    @term = Term.new { value 20; unit :kg }
+    @term.unit.symbol.should eql 'kg'
+    @term.value.should eql 20
+    new_term = @term.convert_unit(:unit => :t)
+    new_term.unit.symbol.should eql 't'
+    new_term.value.should eql 0.020
+  end
+
+  it "should convert per unit" do
+    @term = Term.new { value 20; unit :kg; per_unit :min }
+    @term.unit.symbol.should eql 'kg'
+    @term.per_unit.symbol.should eql 'min'
+    @term.value.should eql 20
+    new_term = @term.convert_unit(:per_unit => :h)
+    new_term.unit.symbol.should eql 'kg'
+    new_term.per_unit.symbol.should eql 'h'
+    new_term.value.should eql 1200.0
+  end
+
+  it "should convert unit and per unit" do
+    @term = Term.new { value 20; unit :kg; per_unit :min }
+    @term.unit.symbol.should eql 'kg'
+    @term.per_unit.symbol.should eql 'min'
+    @term.value.should eql 20
+    new_term = @term.convert_unit( :unit => :t, :per_unit => :h )
+    new_term.unit.symbol.should eql 't'
+    new_term.per_unit.symbol.should eql 'h'
+    new_term.value.should eql 1.2000
+  end
+
+  it "should convert unit if value a string" do
+    @term = Term.new { value "20"; unit :kg }
+    @term.unit.symbol.should eql 'kg'
+    @term.value.should eql "20"
+    new_term = @term.convert_unit(:unit => :t)
+    new_term.unit.symbol.should eql 't'
+    new_term.value.should eql 0.020
+  end
+
+  it "should convert per unit if value a string" do
+    @term = Term.new { value "20"; unit :kg; per_unit :min }
+    @term.unit.symbol.should eql 'kg'
+    @term.per_unit.symbol.should eql 'min'
+    @term.value.should eql "20"
+    new_term = @term.convert_unit(:per_unit => :h)
+    new_term.unit.symbol.should eql 'kg'
+    new_term.per_unit.symbol.should eql 'h'
+    new_term.value.should eql 1200.0
+  end
+
+  it "should convert unit and per unit if value a string" do
+    @term = Term.new { value "20"; unit :kg; per_unit :min }
+    @term.unit.symbol.should eql 'kg'
+    @term.per_unit.symbol.should eql 'min'
+    @term.value.should eql "20"
+    new_term = @term.convert_unit( :unit => :t, :per_unit => :h )
+    new_term.unit.symbol.should eql 't'
+    new_term.per_unit.symbol.should eql 'h'
+    new_term.value.should eql 1.2000
+  end
+
+  it "should raise error if trying to convert to non dimensionally equivalent unit" do
+    @term = Term.new { value 20; unit :kg; per_unit :min }
+    @term.unit.symbol.should eql 'kg'
+    @term.per_unit.symbol.should eql 'min'
+    @term.value.should eql 20
+    lambda{new_term = @term.convert_unit( :unit => :J, :per_unit => :h )}.should raise_error
+  end
+
+  it "should raise error if trying to convert to non dimensionally equivalent unit" do
+    @term = Term.new { value 20; unit :kg; per_unit :min }
+    @term.unit.symbol.should eql 'kg'
+    @term.per_unit.symbol.should eql 'min'
+    @term.value.should eql 20
+    lambda{new_term = @term.convert_unit( :unit => :J, :per_unit => :h )}.should raise_error
+  end
+
+  describe "quantities" do
+
+    it "should convert term with unit to quantity object" do
+      @term = Term.new { value 20; unit :kg }
+      quantity = @term.to_quantity
+      quantity.unit.name.should eql "kilogram"
+      quantity.unit.symbol.should eql "kg"
+      quantity.value.should eql 20.0
+      quantity.to_s.should eql "20.0 kg"
+    end
+
+    it "should convert term with per unit to quantity object" do
+      @term = Term.new { value 20; per_unit :h }
+      quantity = @term.to_quantity
+      quantity.unit.name.should eql "per hour"
+      quantity.unit.symbol.should eql "h^-1"
+      quantity.value.should eql 20.0
+      quantity.to_s.should eql "20.0 h^-1"
+    end
+
+    it "should convert term with unit and per unit to quantity object" do
+      @term = Term.new { value 20; unit :kg; per_unit :h }
+      quantity = @term.to_quantity
+      quantity.unit.name.should eql "kilogram per hour"
+      quantity.unit.symbol.should eql "kg h^-1"
+      quantity.value.should eql 20.0
+      quantity.to_s.should eql "20.0 kg h^-1"
+    end
+
+    it "should return nil with no unit or per unit" do
+      @term = Term.new { value 20 }
+      quantity = @term.to_quantity
+      quantity.should eql 20
+      quantity.should be_a Integer
+    end
+
+    it "should return nil with non numeric term" do
+      @term = Term.new { value "taxi" }
+      quantity = @term.to_quantity
+      quantity.should be_nil
+    end
+
+    it "should convert term with unit to quantity object with alias method" do
+      @term = Term.new { value 20; unit :kg }
+      quantity = @term.to_q
+      quantity.unit.name.should eql "kilogram"
+      quantity.unit.symbol.should eql "kg"
+      quantity.value.should eql 20.0
+      quantity.to_s.should eql "20.0 kg"
+    end
+
+    it "should convert term with per unit to quantity object with alias method" do
+      @term = Term.new { value 20; per_unit :h }
+      quantity = @term.to_q
+      quantity.unit.name.should eql "per hour"
+      quantity.unit.symbol.should eql "h^-1"
+      quantity.value.should eql 20.0
+      quantity.to_s.should eql "20.0 h^-1"
+    end
+  end
+  
+end