plantwatchdog 0.0.1

data/test/test_aggregation_methods.rb

@@ -0,0 +1,50 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__),"..")
+require 'rubygems'
+require 'plantwatchdog/model'
+require 'plantwatchdog/aggregation_methods'
+require 'test/unit'
+require 'test/test_base'
+
+module PlantWatchdog
+  class AggregationMethodsTest < Test::Unit::TestCase
+    include TestUtil
+    include  Aggregation::Methods
+    def test_methods
+      assert_equal(true, Aggregation::Methods.call(:avg, [] ).nan?)
+      assert_equal(1, Aggregation::Methods.call("avg", [1] ))
+      assert_equal(1.5, Aggregation::Methods.call("avg", [1,2] ))
+      assert_equal(2.0, Aggregation::Methods.call("avg", [1.0,3.0] ))
+      assert_nil(Aggregation::Methods.call("unknown", [1.0,3.0] ))
+    end
+
+    def convert a
+      f = s = []
+      a.each {|p| f << p.first; s << p.last}
+      [f, s]
+    end
+
+    def test_each_prior
+      block = Proc.new {|x,y| [x,y]}
+      assert_equal([], [].each_prior(&block))
+      assert_equal([], [1].each_prior( &block))
+      assert_equal([[1,2]], [1,2].each_prior(&block))
+      assert_equal([[1,2],[2,3]], [1,2,3].each_prior(&block))
+    end
+
+    def test_integrate
+      a=[]
+      integrate = Proc.new { Aggregation::Methods.integrate(a.transpose.first, a.transpose.last) }
+      assert_equal(0,  Aggregation::Methods.integrate([], []) )
+      a << [0,0]
+      assert_equal(0, integrate.call )
+      a << [1,1]
+      assert_equal(0.5, integrate.call )
+      a << [1.5,1.5]
+      assert_equal(1.125, integrate.call )
+      a << [5,5]
+      assert_equal(12.5, integrate.call )
+    end
+
+  end
+end

data/test/test_base.rb

@@ -0,0 +1,83 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+require 'rubygems'
+
+module PlantWatchdog
+  module TestUtil
+    def setup type=:sqlite
+      type == :mysql ? setup_mysql : setup_sqlite
+      #setup_sqlite
+      #Model::Schema.migrate(:down)
+      Model::Schema.migrate(:up)
+    end
+
+    def setup_sqlite
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3",
+      :database => ":memory:")
+      #require 'ar-extensions/import/sqlite'
+    end
+
+    def setup_mysql
+      ActiveRecord::Base.establish_connection(:adapter=>"mysql",
+      :database => "solar",
+      :username=>"root",
+      :password=>"root"
+      )
+
+      #require 'ar-extensions/import/mysql'
+
+    end
+
+    def user
+      user = Model::User.find(:first, :conditions => [ "name = 'markus'" ] )
+      return user if user
+      user = Model::User.new
+      user.name = 'markus'
+      user.password = 'markus'
+      user.save()
+      return user
+    end
+
+    def create_inverter(plant = nil)
+
+      if (user.plant.nil?)
+        plant = Model::Plant.new
+        plant.user = user
+        plant.save();
+      end
+
+      inverter = Model::Device.new
+      inverter.plant = user.plant
+      inverter.unique_id = "123"
+      inverter.meta = [["time", "integer"], ["pac", "float"], ["etotal", "integer"]]
+      inverter.save
+
+      return inverter
+    end
+
+    def create_measurement(time, pac, etotal)
+      metadata = user.plant.devices.first.metadata
+      m = metadata.dataclass.new;
+      m.time = time
+      m.pac = pac
+      m.etotal = etotal
+      m
+    end
+
+    def sync(csv, inverter=user.plant.devices.first)
+      Model::SyncManager.new.sync(user, inverter.unique_id, StringIO.new(csv))
+    end
+
+    def write_file(name, content)
+      f = File.new("#{data_dir}#{name}", "w")
+      f.write(content)
+      f.close
+    end
+
+    def data_dir
+      dirname = "#{File.dirname(__FILE__)}/unit_test_generated/"
+      FileUtils.mkdir(dirname) unless File.exists?(dirname)
+      dirname
+    end
+
+  end
+end

data/test/test_data.rb

@@ -0,0 +1,118 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__),"..")
+require 'rubygems'
+require 'plantwatchdog/data'
+require 'test/unit'
+require 'test/test_base'
+
+module PlantWatchdog
+  class DataTest < Test::Unit::TestCase
+    include TestUtil
+    include Datadetection
+    def test_raw_data_years
+      inverter1 = create_inverter
+
+      year = 2006
+      date = Time.utc(year, "jan", 2, 5, 0, 0)
+
+      # add a measurement for inverter1
+      Model::MeasurementChunk.save_measurements(inverter1, [create_measurement(date.tv_sec, 25.0, 10000)])
+
+      assert_equal [year], years_with_data(user)
+      assert_equal [2], days_with_data(user, 2006)
+
+      # add inverter2 and a measurement for another day in the same year
+      date = Time.utc(year, "feb", 1, 5, 0, 0)
+      inverter2 = create_inverter
+      Model::MeasurementChunk.save_measurements(inverter1, [create_measurement(date.tv_sec, 25.0, 10000)])
+      Model::MeasurementChunk.save_measurements(inverter2, [create_measurement(date.tv_sec, 25.0, 10000)])
+      assert_equal [year], years_with_data(user)
+      assert_equal [2,32], days_with_data(user, 2006)
+
+      # add a measurement for the next year
+      date = Time.utc(year+1, "feb", 2, 5, 0, 0)
+      Model::MeasurementChunk.save_measurements(inverter2, [create_measurement(date.tv_sec, 25.0, 10000)])
+      assert_equal [year, year+1], years_with_data(user)
+      assert_equal [33], days_with_data(user, 2007)
+    end
+
+    def test_day_of_year_converter
+      # 2000 is a switch year
+      dayc = DayOfYearConverter.new(2000, [1,60])
+      assert_equal [1,2], dayc.months
+      assert_equal [1], dayc.days(1)
+      assert_equal [29], dayc.days(2)
+      assert_equal [], dayc.days(3)
+      dayc = DayOfYearConverter.new(2001, [1,60])
+      assert_equal [1,3], dayc.months
+      assert_equal [1], dayc.days(1)
+      assert_equal [], dayc.days(2)
+      assert_equal [1], dayc.days(3)
+    end
+
+    def test_series
+      inverter = create_inverter
+      date = Time.utc(2001, "jan", 2, 12, 0, 0)
+
+      # add a measurement for inverter1
+      Model::MeasurementChunk.save_measurements(inverter, [create_measurement(date.tv_sec, 25.1, 101)])
+      ENV["TZ"] = "Europe/Berlin" # set timezone
+      ts = time_series(inverter, 2001, 2)
+      ts_pac = ts["pac"]
+      utc_offset = 3600 # Berlin is GMT+1 in January
+      # the time in timeseries is milliseconds and faked local time:
+      # the secs_since_epoch is adjusted to fake local time, see flot documentation
+      assert_equal([(date.tv_sec + utc_offset)*1000, 25.1], ts_pac[0])
+
+      ts_etotal=ts["etotal"]
+      assert_equal([(date.tv_sec + utc_offset)*1000, 101], ts_etotal[0])
+
+    end
+
+    def test_plant_agg
+      create_inverter
+      plant = user.plant
+      plant.aggrules = { "eday" => [:sum, "eday"] }
+      plant.save
+      ma1 = Model::MeasurementAggregate.new
+      ma1.plant = plant
+      ma1.data = { "eday" => 1.2 }
+      ma1.time_year = 2010
+      ma1.time_day_of_year = 20
+      ma1.save!
+
+      # 2010-21 missing
+
+      ma2 = Model::MeasurementAggregate.new
+      ma2.plant = plant
+      ma2.data = { "eday" => 1.4 , "another" => 1 }
+      ma2.time_year = 2010
+      ma2.time_day_of_year = 22
+      ma2.save!
+
+      ma3 = Model::MeasurementAggregate.new
+      ma3.plant = plant
+      ma3.data = { "another" => 1 }
+      ma3.time_year = 2010
+      ma3.time_day_of_year = 23
+      ma3.save!
+
+      aggs = plant_aggregates(plant, [[2010,19],[2010,20],[2010,21],[2010,22],[2010,23]])
+      ENV["TZ"] = "Europe/Berlin" # set timezone
+      millis = Time.utc(2010, "jan", 19, 12, 0, 0).tv_sec*1000
+      day_millis = 3600*24*1000
+      # TODO NaN instead of 0
+      assert_equal( [[millis, 0], [millis+day_millis, 1.2], [millis+day_millis*2, 0], [millis+day_millis*3, 1.4], [millis+day_millis*4, 0]], aggs["eday"])
+    end
+
+    include Monthhelper
+
+    def test_monthhelper
+      assert_equal(31, days_of_month(2000, 1).size)
+      assert_equal(29, days_of_month(2000, 2).size)
+      assert_equal(30, days_of_month(2000, 4).size)
+      assert_equal(28, days_of_month(2001, 2).size)
+    end
+
+  end
+end

data/test/test_model.rb

@@ -0,0 +1,142 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__),"..")
+require 'rubygems'
+require 'plantwatchdog/model'
+require 'test/unit'
+require 'test/test_base'
+
+module PlantWatchdog
+  class ModelTest < Test::Unit::TestCase
+    include TestUtil
+    def test_measurement_parse_csv
+      inverter = create_inverter
+
+      year = 2006
+      date = Time.utc(year, "jan", 2, 8, 0, 0)
+
+      assert_equal([], Model::Measurement.parse_csv(inverter.metadata, nil))
+      assert_equal([], Model::Measurement.parse_csv(inverter.metadata, ""))
+
+      csv = "#{date.tv_sec},25.00,10000"
+      actual = Model::Measurement.parse_csv inverter.metadata, csv
+      expected =  [ create_measurement(date.tv_sec, 25.0, 10000) ]
+      assert_equal(expected, actual)
+
+      # to_csv: a measurement instance must preserver the original line
+      assert_equal(csv, actual.first.line)
+
+      # expected.first has not been created from a csv line, the line
+      # must be created according to the metadata, therefore 25.0 will
+      # be serialized as "25.0"
+      assert_equal("#{date.tv_sec},25.0,10000", expected.first.line)
+    end
+
+    def test_save_measurement
+      inverter = create_inverter
+      ENV["TZ"] = "Europe/Berlin"
+      year = 2006
+      date = Time.utc(year, "jan", 1, 23, 0, 0) # this is January 2, 00:00:00 in Berlin
+
+      m = create_measurement(date.tv_sec, 25.0, 10000)
+      Model::MeasurementChunk.save_measurements(inverter, [m])
+
+      # re-read the chunk and therefore go through the complete de-serialization
+      c = Model::MeasurementChunk.find(:first)
+      assert_equal(year, c.time_year)
+      assert_equal(2, c.time_day_of_year)
+      assert_equal(m, c.measurements.first)
+
+      # create a new chunk for another inverter on the same day
+      inverter2 = create_inverter
+      Model::MeasurementChunk.save_measurements(inverter2, [m])
+      c = Model::MeasurementChunk.find(:first, :conditions => [ "device_id=?", inverter2.id ])
+      assert_equal(year, c.time_year)
+      assert_equal(2, c.time_day_of_year)
+
+    end
+
+    def test_measurement_partition
+      create_inverter()
+      year = 2006
+      date1 = Time.utc(year, "jan", 2, 8, 0, 0)
+      date2 = Time.utc(year, "jan", 3, 8, 0, 0)
+
+      measurements = []
+      dict = Model::Measurement.partition_by_day measurements
+      assert(dict.empty?)
+
+      # one measurement, one day
+      measurements << create_measurement(date1.tv_sec, 25.0, 10000)
+      dict = Model::Measurement.partition_by_day measurements
+      assert_equal(measurements, dict[[year,2]])
+
+      # two measurements, one day
+      measurements << create_measurement(date1.tv_sec + 1000, 25.0, 10000)
+      dict = Model::Measurement.partition_by_day measurements
+      assert_equal(measurements, dict[[year,2]])
+
+      # three measurements, two days
+      measurements << create_measurement(date2.tv_sec, 25.0, 10000)
+      dict = Model::Measurement.partition_by_day measurements
+      assert_equal(measurements[0,2], dict[[year,2]])
+      assert_equal([measurements.last], dict[[year,3]])
+    end
+
+    def test_metadata_and_aggrules_conversion
+      device = Model::Device.new
+      # set metadata and aggrules via conveniance setters ...
+      aggrules =  { "k" => [ "m", "p1"] } # TODO: Hash keys should be symbols, but default encoding/decoding to json only uses strings
+      device.aggrules = aggrules
+      device.meta = ["col1", "col2"]
+      device.save!
+
+      act_device = Model::Device.find(:first)
+      # and check that the dict and array was transformed to JSON
+      # access active record attributes directly since getter is overwritten
+      assert_equal( '["col1","col2"]' , device.metadata["description"])
+      assert_equal( '{"k":["m","p1"]}', device.aggregationrule["description"])
+
+      # now check that the JSON from the descriptions has been transformed to ruby array and dict
+      assert_equal( act_device.meta, device.meta)
+      assert_equal( aggrules, act_device.aggrules)
+
+      # check that updating meta and saving again creates a new
+      # metadata row and the old one is preserved
+      existing_metadata_id = device.metadata.id
+      device.meta = ["col1", "col2", "col3"]
+      device.save!
+      assert(existing_metadata_id < device.metadata.id)
+      act_device = Model::Device.find(:first)
+      assert_equal( '["col1","col2","col3"]' , device.metadata["description"])
+      old_metadata = Model::Metadata.find(:first, :conditions =>  ["id=?", existing_metadata_id])
+
+      assert_equal('["col1","col2"]' , old_metadata["description"])
+
+      # assigning the same metadata again must not create a new metadata instance
+      current_metadata_id = device.metadata.id
+      device.meta = ["col1", "col2", "col3"]
+      device.save!
+      assert( device.metadata.id == current_metadata_id)
+
+    end
+
+    def test_metadata
+      # every metadata instance dynamically creates one subclass of BaseWithoutTable
+      meta = Model::Metadata.new
+      meta.description = '["default",["time","integer"],["value","float"]]'
+      assert_equal(["default",["time","integer"],["value","float"]],  meta.description)
+      cols = meta.dataclass.columns
+      assert_equal("default", cols.first.name)
+      assert_equal(nil, cols.first.type)
+      assert_equal("time", cols[1].name)
+      assert_equal(:integer, cols[1].type)
+      assert_equal("value", cols.last.name)
+      assert_equal(:float, cols.last.type)
+
+      # ensure there is exactly one class created for every metadata row
+      meta.save!
+      loadedMeta = Model::Metadata.find(:first)
+      assert_same(meta.dataclass, loadedMeta.dataclass)
+    end
+  end
+end

data/test/test_sync.rb

@@ -0,0 +1,71 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+$:.unshift File.join(File.dirname(__FILE__),"..")
+require 'rubygems'
+require 'plantwatchdog/model'
+require 'test/unit'
+require 'test/test_base'
+
+module PlantWatchdog
+  class SyncTest < Test::Unit::TestCase
+    include TestUtil
+    def test_sync_inverter
+      # sync inverter
+      inverter = create_inverter()
+      inverter.save
+      year = 2005
+      day = 5
+      syncTime = Time.utc(year, "jan", day, 15, 0, 0)
+
+      syncManager = Model::SyncManager.new
+      # latest is 0 if there has not been a synchronization yet
+      assert_equal(0, syncManager.latest(user, inverter.unique_id))
+      csv_line1 = "#{syncTime.tv_sec},20,1000"
+      sync(csv_line1)
+
+      # check that there is an entry in the sync table after the first sync
+      assert_equal(syncTime.tv_sec, syncManager.latest(user, inverter.unique_id))
+
+      ims = Model::MeasurementChunk.find(:first, :conditions => ["device_id=?", inverter.id]);
+      assert_equal(csv_line1, ims.data)
+
+      # has the user's start_year been updated, too?
+      assert_equal(Time.at(syncTime.tv_sec).utc.year, user.start_year)
+
+      # we are only allowed to upload more recent data
+      assert_raise(Model::SyncError) do
+        sync("#{syncTime.tv_sec - 5},20,1000")
+      end
+
+      syncTime += 3600 # one hour later
+
+      # sync the next chunk on the same day
+      csv_line2 = "#{syncTime.tv_sec},0,1200"
+      sync(csv_line2)
+
+      assert_equal(syncTime.tv_sec, syncManager.latest(user, inverter.unique_id))
+
+      ims = Model::MeasurementChunk.find(:first, :conditions => ["device_id=?", inverter.id]);
+      assert_equal("#{csv_line1}\n#{csv_line2}", ims.data)
+
+      # sync another chunk, this time containing data spanning two days
+      syncTime = Time.utc(year, "jan", 6, 15, 0, 0)
+      csv_line_day_6 = "#{syncTime.tv_sec},0,1300"
+      syncTime = Time.utc(year, "jan", 7, 14, 0, 0)
+      csv_line_day_7 = "#{syncTime.tv_sec},0,1400"
+      sync("#{csv_line_day_6}\n#{csv_line_day_7}")
+
+      # check data of day 6
+      ims = Model::MeasurementChunk.find(:first, :conditions => ["time_year=? and time_day_of_year=?", year, 6]);
+      assert_equal("#{csv_line_day_6}", ims.data)
+      # check data of day 7
+      ims = Model::MeasurementChunk.find(:first, :conditions => ["time_year=? and time_day_of_year=?", year, 7]);
+      assert_equal("#{csv_line_day_7}", ims.data)
+    end
+
+    def test_sync_invalid_unique_id
+      assert_raise(Model::SyncError) do
+        Model::SyncManager.new.sync(user, "unkown", StringIO.new("1234,20,1000"))
+      end
+    end
+  end
+end