amee-data-abstraction 1.0.0

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

@@ -0,0 +1,53 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+describe TermsList do
+  it 'should be returned from calculations' do
+    Transport.terms.should be_a TermsList
+  end
+  it 'should give properties' do
+    Transport.terms.labels.should eql [:fuel,:size,:distance,:co2]
+    Transport.terms.paths.should eql ['fuel','size','distance',:default]
+    Transport.terms.names.should eql ['Fuel Type','Vehicle Size','Distance Driven','Carbon Dioxide']
+  end
+  it 'should select by class' do
+    Transport.terms.drills.labels.should eql [:fuel,:size]
+    Transport.terms.profiles.labels.should eql [:distance]
+    Transport.terms.outputs.labels.should eql [:co2]
+  end
+  it 'should select by property' do
+    t=Transport.begin_calculation
+    t[:distance].value 5
+    t.terms.set.labels.should eql [:distance]
+    t.terms.unset.labels.should eql [:fuel,:size,:co2]
+  end
+  it 'should select by chain' do
+    t=Transport.begin_calculation
+    t[:fuel].value 'diesel'
+    t.terms.drills.set.labels.should eql [:fuel]
+    t.terms.drills.unset.labels.should eql [:size]
+    t.terms.set.drills.labels.should eql [:fuel]
+    t.terms.unset.drills.labels.should eql [:size]
+  end
+  it 'should select by order' do
+    t=Transport.clone
+    t.terms.before(:distance).labels.
+      should eql [:fuel,:size]
+    t.terms.after(:distance).labels.
+      should eql [:co2]
+  end
+  it 'can select terms by usage' do
+    mocker=AMEEMocker.new self,:path=>'transport/car/generic'
+    mocker.item_value_definitions.
+      item_definition.data_category.
+      item_value_definition('distance',['usage1'],['usage2'],['usage3'])
+    t=Transport.clone
+    t.profiles.compulsory('usage1').labels.should eql [:distance]
+    t.profiles.optional('usage2').labels.should eql [:distance]
+    t.profiles.compulsory('usage2').labels.should be_empty
+    t.profiles.optional('usage1').labels.should be_empty
+    t.profiles.in_use('usage2').labels.should eql [:distance]
+    t.profiles.in_use('usage1').labels.should eql [:distance]
+    t.profiles.in_use('usage3').labels.should be_empty
+  end
+ 
+end

data/spec/config/amee_units_spec.rb

@@ -0,0 +1,71 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "AMEE units" do
+  
+  include Quantify
+
+  # The Unit.<unit_name_symbol_or_label> pattern retrieves the unit which is
+  # provided as the (pseudo) method name (using #method_missing). In cases where
+  # the named unit does not exist an error is raised. In some cases, however,
+  # where the unit can be constructed from a known and compatible unit and prefix
+  # combination, it is created but not loaded to the canonical system of units.
+  # Therefore, to test for presence or absence of partiuclar units, we check that
+  # the units we want are #loaded? and that the ones we don't want are either NOT
+  # #loaded? (if the happen to be derivable) or otherwise raise an error.
+
+  it "should include commonly used SI units" do
+    Unit.metre.should be_loaded
+    Unit.second.should be_loaded
+    Unit.kg.should be_loaded
+  end
+
+  it "should include commonly used non SI units" do
+    Unit.foot.should be_loaded
+    Unit.pound.should be_loaded
+    Unit.month.should be_loaded
+  end
+
+  it "should exclude uncommonly used SI units" do
+    Unit.micrometre.should_not be_loaded
+    lambda{Unit.galileo}.should raise_error
+    lambda{Unit.inverse_centimetre}.should raise_error
+  end
+
+  it "should exclude uncommonly used non SI units" do
+    lambda{Unit.astronomical_unit}.should raise_error
+    lambda{Unit.dyne_centimetre}.should raise_error
+    lambda{Unit.maxwell}.should raise_error
+  end
+
+  it "should include commonly used SI units and prefixes" do
+    Unit.terajoule.should be_loaded
+    Unit.gigagram.should be_loaded
+    Unit.megawatt.should be_loaded
+  end
+
+  it "should include commonly used Non SI units and prefixes" do
+    Unit.MBTU.should be_loaded
+  end
+
+  it "should exclude uncommonly used SI units and prefixes" do
+    Unit.microjoule.should_not be_loaded
+    Unit.nanogram.should_not be_loaded
+    Unit.picowatt.should_not be_loaded
+  end
+
+  it "should represent the BTU with the 59F version" do
+    Unit.BTU.label.should eql "BTU_FiftyNineF"
+  end
+
+  it "should label the unit for 'day' as 'day'" do
+    Unit.day.label.should eql 'day'
+  end
+
+  it "should recognise the unit for megawatt_hour as 'MWh'" do
+    Unit.megawatt_hour.label.should eql 'MWh'
+    Unit.megawatt_hour.symbol.should eql 'MWh'
+  end
+
+end
+

data/spec/core-extensions/class_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+ class Myclass
+     attr_property :prop
+   end
+
+describe Class do
+  before :all do
+    @it=Myclass.new
+  end
+ it 'can have a property defined' do
+  @it.prop 5
+  @it.prop.should eql 5
+ end
+ it 'can have a prop unset' do
+   @it.prop 5
+   @it.prop nil
+   @it.prop.should be_nil
+ end
+ it 'does not unset by query' do
+   @it.prop 5
+   @it.prop
+   @it.prop.should_not be_nil
+ end
+end

data/spec/core-extensions/hash_spec.rb

@@ -0,0 +1,44 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Hash do
+  before(:each) do
+    @hash = { 'first_name' => 'Kenny',
+              'last_name' => 'Rogers',
+              'date_of_birth' => {'day' => 17,
+                                  'month' => 'April',
+                                  'year' => 1939 },
+              'interests' => [ {'movie' => 'Birds',
+                                'book' => 'Catch 22'},
+                               "guitar",
+                               {'song' => 'Leaving On a Jetplane'} ],
+              :already_a_symbol => 'dummy' }
+  end
+
+  it "should symbolize keys, returning new hash" do
+    new_hash = @hash.recursive_symbolize_keys
+    new_hash.keys.size.should eql 5
+    new_hash.keys.each { |k| k.should be_a Symbol }
+    new_hash[:first_name].should eql 'Kenny'
+    new_hash[:date_of_birth].should be_a Hash
+    new_hash[:date_of_birth].keys.each { |k| k.should be_a Symbol }
+    new_hash[:date_of_birth][:month].should eql 'April'
+    new_hash[:interests].should be_a Array
+    new_hash[:interests][0].keys.each { |k| k.should be_a Symbol }
+    new_hash[:interests][0][:movie].should eql 'Birds'
+  end
+
+  it "should symbolize keys in place, returning self" do
+    @hash.recursive_symbolize_keys!
+    @hash.keys.size.should eql 5
+    @hash.keys.each { |k| k.should be_a Symbol }
+    @hash[:first_name].should eql 'Kenny'
+    @hash[:date_of_birth].should be_a Hash
+    @hash[:date_of_birth].keys.each { |k| k.should be_a Symbol }
+    @hash[:date_of_birth][:month].should eql 'April'
+    @hash[:interests].should be_a Array
+    @hash[:interests][0].keys.each { |k| k.should be_a Symbol }
+    @hash[:interests][0][:movie].should eql 'Birds'
+  end
+end
+

data/spec/core-extensions/ordered_hash_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+
+describe ActiveSupport::OrderedHash do
+  it 'Can insert at start' do
+    x=ActiveSupport::OrderedHash[[[1,2],[3,4]]]
+    x.keys.should eql [1,3]
+    x.insert_at_start(5,6)
+    x.keys.should eql [5,1,3]
+    x.to_a.should eql [[5,6],[1,2],[3,4]]
+  end
+end

data/spec/core-extensions/proc_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(File.dirname(__FILE__)) + '/spec_helper.rb'
+
+describe Proc do
+  before :all do
+    @it=Proc.new{|x|x.is_a? Float}
+  end
+ it 'uses call as ===' do
+  (@it===3.4).should be_true
+  (@it===7).should be_false
+  (@it==='hello').should be_false
+ end
+end

data/spec/fixtures/electricity.rb

@@ -0,0 +1,35 @@
+Electricity=AMEE::DataAbstraction::PrototypeCalculation.new { # The application has support for an electricity calculation. :electricity is the internal label used to refer to it
+  label :electricity
+  name "Electricity Consumption"
+  path '/business/energy/electricity/grid'
+  
+  drill {
+    fixed 'argentina' #Not to be unset, value pre-given
+    label :country  #Name will default to label.humanize if not given
+    path 'country' #Some of the fields on the form are drill-downs, but the application doesn't need to display these differently
+    #type :autocompleting_text_box #default for a drill with entries is probably a dropdown
+  }
+
+  profile {
+    label :energy_used
+    # Symbol provided here is used in generating html ids for elements etc
+    path 'energyPerTime' #The amee profile item value corresponding to the field
+    name "Energy Used" #The display name used on the form
+    unit "kWh" #Default unit choice
+    interface :text_box #Probably not needed, as likely to be the default for profile item value unsets
+    validation lambda{|x|x.is_a? Float} #Probably not needed, as default can be deduced from PIV TYPE in API. Here as illustrative.
+    alternative_units :MWh, :MBTU, :BTU # If these are explcitly specified then the alternatives are limited to only these units. Otherwise all dimensionally equivalent units are available as alternatives by default
+  }
+  
+  # Alternatively, the drill might be fixed
+  #permanent :country {
+  #   drill_path 'country'
+  #   value 'Argentina'
+
+  output { #A marv output value
+    label :co2
+    path :default #It's not a marv, use the default output
+    name "Carbon Dioxide"
+  }
+}
+

data/spec/fixtures/electricity_and_transport.rb

@@ -0,0 +1,55 @@
+ElectricityAndTransport=AMEE::DataAbstraction::CalculationSet.new {
+  all_calculations {
+    metadatum {
+      label :department
+      choices %w{stuff things more_stuff meta_things}
+    }
+  }
+
+  calculation{
+    name 'electricity'
+    label :electricity
+    path '/business/energy/electricity/grid'
+    profile {
+      label :usage
+      name 'Electricity Used'
+      path 'energyPerTime'
+    }
+    drill {
+      label :country
+      path 'country'
+      fixed 'Argentina'
+    }
+    output {
+      label :co2
+      path :default
+    }
+  }
+
+  calculation {
+    name 'transport'
+    label :transport
+    path '/transport/car/generic'
+
+    drill {
+      path 'fuel'
+      label :fuel
+      name 'Fuel Type'
+    }
+    drill {
+      path 'size'
+      label :size
+      name 'Vehicle Size'
+    }
+    profile {
+      path 'distance'
+      label :distance
+      name 'Distance Driven'
+    }
+    output {
+      label :co2
+      path :default
+      name 'Carbon Dioxide'
+    }
+  }
+}

data/spec/fixtures/transport.rb

@@ -0,0 +1,26 @@
+Transport=AMEE::DataAbstraction::PrototypeCalculation.new{
+  name 'transport'
+  label :transport
+  path '/transport/car/generic'
+
+  drill {
+    path 'fuel'
+    label :fuel
+    name 'Fuel Type'
+  }
+  drill {
+    path 'size'
+    label :size
+    name 'Vehicle Size'
+  }
+  profile {
+    path 'distance'
+    label :distance
+    name 'Distance Driven'
+  }
+  output {
+    label :co2
+    path :default
+    name 'Carbon Dioxide'
+  }
+}

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format RspecSpinner::Bar

data/spec/spec_helper.rb

@@ -0,0 +1,244 @@
+require 'rubygems'
+require 'spec'
+require 'rspec_spinner'
+require 'flexmock'
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'amee'
+require 'amee-data-abstraction'
+
+Spec::Runner.configure do |config|
+  config.mock_with :flexmock
+end
+
+AMEE::DataAbstraction.connection=FlexMock.new('connection') #Global connection mock, shouldn't receive anything, as we mock the individual amee-ruby calls in the tests
+
+Dir.glob(File.dirname(__FILE__) + '/fixtures/*') do |filename|
+  require filename
+end
+
+include AMEE::DataAbstraction
+
+class AMEEMocker
+  def initialize(test,options)
+    @path=options[:path]
+    sel=options[:selections]||[]
+    @selections=ActiveSupport::OrderedHash[sel]
+    @choices=options[:choices]||[]
+    @result=options[:result]
+    @params=options[:params]||{}
+    @existing=options[:existing]||{}
+    @test=test
+    @mock_dc=test.flexmock(:path=>"/data/#{path}")
+    @mock_id=test.flexmock
+    @mock_ivds=[]
+    @mock_rvds=[]
+  end
+
+  attr_accessor :path,:selections,:choices,:result,:params,
+    :existing,:mock_dc,:mock_id,:mock_ivds,:mock_rvds
+
+  attr_reader :test
+
+  def catuid
+    path.gsub(/\//,'-').to_sym
+  end
+
+  def select(opts)
+    # Like an array of pairs, not a hash, for ordering reasons.
+    opts.each do |k,v|
+      @selections[k]=v
+    end
+  end
+
+  def connection
+    AMEE::DataAbstraction.connection
+  end
+
+  def dataitemuid
+    "#{catuid}:#{selections.map{|k,v|"#{k}-#{v}"}.join('-')}"
+  end
+
+  def uid
+    dataitemuid+"PI"
+  end
+
+  def pipath
+    "/profiles/someprofileuid/#{path}/#{uid}"
+  end
+
+  def dipath
+    "/data/#{path}/#{dataitemuid}"
+  end
+
+  def drill
+    test.flexmock(AMEE::Data::DrillDown).
+      should_receive(:get).
+      with(connection,
+      "/data/#{path}/drill?#{selections.map{|k,v|"#{k}=#{v}"}.join('&')}").
+      at_least.once.
+      and_return(test.flexmock(:choices=>choices,:selections=>Hash[selections],
+        :data_item_uid=>dataitemuid))
+    return self
+  end
+
+  def profile_list
+    test.flexmock(AMEE::Profile::ProfileList).should_receive(:new).
+      with(connection).at_least.once.
+      and_return(test.flexmock(:first=>test.flexmock(:uid=>:someprofileuid)))
+    return self
+  end
+
+  def timestamp
+    test.flexmock(UUIDTools::UUID).should_receive(:timestamp_create).at_least.once.
+      and_return(:sometimestamp)
+    return self
+  end
+
+  def profile_category
+    test.flexmock(AMEE::Profile::Category).should_receive(:get).
+      with(connection,"/profiles/someprofileuid/#{path}").at_least.once.
+      and_return(catuid)
+    return self
+  end
+
+  def itemdef_drills(some_drills)
+    mock_id.should_receive(:drill_downs).and_return(some_drills)
+    return self
+  end
+  
+  def return_value_definition(path,unit=nil,per_unit=nil)
+    rvd=test.flexmock :name=>path
+    rvd.should_receive(:unit).and_return unit
+    rvd.should_receive(:perunit).and_return per_unit
+    mock_rvds.push rvd
+    return self
+  end
+
+  def return_value_definitions
+    test.flexmock(AMEE::Admin::ReturnValueDefinitionList).should_receive(:new).
+        with(connection,:itemdefuid).and_return mock_rvds
+      return self
+  end
+
+  def item_value_definition_metadata(meta)
+    AMEE::Admin::ItemValueDefinition.new(:meta=>meta).meta
+  end
+
+  def item_value_definition(path,compulsories=[],optionals=[],forbiddens=[],choices=[],unit=nil,per_unit=nil,profile=true,drill=false,default=nil,type=nil,wikidoc=nil)
+    ivd=test.flexmock :path=>path
+    ivd.should_receive(:name).and_return path.to_s.humanize
+    ivd.should_receive(:profile?).and_return profile
+    ivd.should_receive(:drill?).and_return drill
+    ivd.should_receive(:versions).and_return ['2.0']
+    ivd.should_receive(:unit).and_return unit
+    ivd.should_receive(:perunit).and_return per_unit
+    ivd.should_receive(:choices).and_return choices
+    ivd.should_receive(:default).and_return default
+    ivd.should_receive(:valuetype).and_return type
+    ivd.should_receive(:meta).and_return(item_value_definition_metadata(:wikidoc=>wikidoc))#.should_receive(:wikidoc).and_return wikidoc
+    compulsories.each do |compulsory|
+      ivd.should_receive(:compulsory?).with(compulsory).and_return(true)
+      ivd.should_receive(:optional?).with(compulsory).and_return(false)
+    end
+    optionals.each do |optional|
+      ivd.should_receive(:optional?).with(optional).and_return(true)
+      ivd.should_receive(:compulsory?).with(optional).and_return(false)
+    end
+    forbiddens.each do |forbidden|
+      ivd.should_receive(:optional?).with(forbidden).and_return(false)
+      ivd.should_receive(:compulsory?).with(forbidden).and_return(false)
+    end
+    mock_ivds.push ivd
+    return self
+  end
+
+  def item_value_definitions
+    mock_id.should_receive(:item_value_definition_list).at_least.once.and_return(mock_ivds)
+    return self
+  end
+
+  def usages(someusages)
+    mock_id.should_receive(:usages).and_return(someusages)
+    return self
+  end
+
+  def item_definition(name=:itemdef_name)
+    mock_id.should_receive(:name).and_return(name)
+    mock_id.should_receive(:uid).and_return(:itemdefuid)
+    mock_dc.should_receive(:item_definition).at_least.once.and_return(mock_id)
+    return self
+  end
+
+  def data_category
+    test.flexmock(AMEE::Data::Category).should_receive(:get).
+      with(connection,"/data/#{path}").at_least.once.
+      and_return(mock_dc)
+    return self
+  end
+
+  def create
+    test.flexmock(AMEE::Profile::Item).should_receive(:create).
+      with(catuid,dataitemuid,
+      {:get_item=>false,:name=>:sometimestamp}.merge(params)).
+      at_least.once.
+      and_return(pipath)
+    return self
+  end
+
+  def get(with_pi=false,failing=false,once=false)
+    mock_pi=test.flexmock(
+      :amounts=>test.flexmock(:find=>{:value=>result}),
+      :data_item_uid=>dataitemuid
+    )
+    mock_di=test.flexmock
+    if with_pi
+      from_amee=existing.clone
+      params.each {|key,val| from_amee.delete key}
+      from_amee.each do |k,v|
+        if failing
+          mock_pi.should_receive(:values).and_return([{:path => k,:value => v }])
+        else
+          mock_pi.should_receive(:values).and_return([{:path => k,:value => v }]).once
+        end
+      end
+      selections.each do |k,v|
+        if failing
+          mock_di.should_receive(:value).with(k).and_return(v)
+        else
+          mock_di.should_receive(:value).with(k).and_return(v).once
+        end
+      end
+      test.flexmock(AMEE::Data::Item).should_receive(:get).
+        with(connection,dipath,{}).
+        at_least.once.
+        and_return(mock_di)
+    end
+    if once
+      test.flexmock(AMEE::Profile::Item).should_receive(:get).
+      with(connection,pipath,{}).
+      at_least.once.
+      and_return(mock_pi)
+    else
+    test.flexmock(AMEE::Profile::Item).should_receive(:get).
+      with(connection,pipath,{}).
+      at_least.once.
+      and_return(mock_pi)
+    end
+    return self
+  end
+
+  def delete
+    test.flexmock(AMEE::Profile::Item).should_receive(:delete).
+      at_least.once.
+      with(connection,pipath)
+    return self
+  end
+
+  def update
+    test.flexmock(AMEE::Profile::Item).should_receive(:update).
+      with(connection,pipath,
+      {:get_item=>false}.merge(existing).merge(params)).
+      at_least.once
+    return self
+  end
+end