nera 0.1.2 → 0.2.0

data/lib/nera/nera_run_records.rb

@@ -24,11 +24,20 @@ module NERA
     attr_accessor :keys
     
     # run record
-    def initialize( table_file)
+    def initialize( table_file, param_recs, param_id)
+      raise ArgumentError unless param_recs.is_a?( NERA::ParameterRecords) and param_id.is_a?(Integer)
+      
       @keys = ATTRIBUTES.map do |k| k[0] end
-      @db = NERA::Database.new( table_file)
+      @db = NERA::Database.new( table_file, param_id)
+      @db.add_observer( param_recs)
     end
 
+    # argument is the path to runs.yml
+    def set_yaml_file( yaml_path)
+      @db.set_yaml_file( yaml_path)
+    end
+
+
     def self.create_table(table_file)
       NERA::Database.create_table( table_file)
     end

data/lib/nera/nera_simulator_layer_controller.rb

@@ -17,6 +17,7 @@ module NERA
       @db_folders = NERA::DbFolders.new( path_db_folds)
       table_path = @db_folders.path_to_simulators_table
       @sim_records = NERA::SimulatorRecords.new(table_path)
+      @sim_records.set_yaml_file( @db_folders.path_to_simulators_yaml )
 
       NERA::Simulator.inherited_simulators.each do |sim|
         next if list.find do |rec| rec[:name] == sim.to_s end
@@ -55,20 +56,13 @@ module NERA
         path = @db_folders.path_to_parameters_table( sim_klass)
         c = NERA::ParameterRecords.create_table( path, sim_klass)
         raise "The file #{path} already exists." unless c
+        @db_folders.logger.info(self.class.to_s) {
+          "registered the simulator (#{sim_klass.to_s})"
+        }
       }
-      dump_in_yaml
       return a
     end
 
-    private
-    def dump_in_yaml
-      ymlpath = @db_folders.path_to_simulators_yaml
-      File.open( ymlpath, 'w') do |io|
-        YAML::dump( @sim_records.list, io)
-        io.flush
-      end
-    end
-
   end
 
 end

data/lib/nera/nera_simulator_records.rb

@@ -1,5 +1,6 @@
 require 'nera_database'
 require 'nera_simulator'
+require 'observer'
 
 module NERA
 
@@ -17,6 +18,11 @@ module NERA
       @db = NERA::Database.new( db_file)
     end
 
+    # argument is the path to simulators.yml
+    def set_yaml_file( yaml_path)
+      @db.set_yaml_file( yaml_path)
+    end
+
     # if file already exists, returns false
     def self.create_table( db_file)
       NERA::Database.create_table( db_file)
@@ -69,6 +75,8 @@ module NERA
       @db.update( rec)
     end
 
+    alias :update :touch
+
     def destroy( id)
       raise ArgumentError unless id.is_a?(Integer)
       @db.destroy(id)

data/lib/nera.rb

@@ -22,5 +22,5 @@ require 'nera_simulator_records'
 require 'nera_remote_connector'
 
 module NERA
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/test/test_nera_database.rb

@@ -8,7 +8,7 @@ class TC_NERA_DB < Test::Unit::TestCase
     FileUtils.chdir(@test_dir)
     @path_to_db = "./testdb"
     NERA::Database.create_table( @path_to_db)
-    @db = NERA::Database.new( @path_to_db)
+    @db = NERA::Database.new( @path_to_db, 'arg')
   end
 
   def teardown
@@ -20,6 +20,68 @@ class TC_NERA_DB < Test::Unit::TestCase
     assert_raise( RuntimeError ) { ( NERA::Database.new("Unknown") ) }
   end
 
+  def test_observable
+    a = 'a'
+    def a.update( arg)
+      upcase!
+    end
+    @db.add_observer( a)
+    record = { :key1 => 3, :key2 => 3.0}
+    @db.add( record)
+    assert_equal( 'A', a)
+
+    a.downcase!
+    rec = @db.find_by_id(1)
+    assert_equal( 'a', a)
+    rec[:key3] = 4.0
+    @db.update( rec)
+    assert_equal( 'A', a)
+
+    a.downcase!
+    @db.destroy(1)
+    assert_equal( 'A', a)
+
+    a.downcase!
+    @db.transaction do
+      @db.add(record)
+      assert_equal( 'a', a)
+      @db.destroy( 2)
+      assert_equal( 'a', a)
+    end
+    assert_equal( 'A', a)
+    
+    a.downcase!
+    assert_raise(RuntimeError) {
+      @db.transaction do
+        @db.add( {:key1 => 99, :key2 => 2} )
+        raise
+      end
+    }
+    assert_equal( 'a', a)
+    
+  end
+
+  def test_set_yaml_file
+    @db.set_yaml_file('rec.yml')
+
+    record = { :key1 => 3, :key2 => 3.0}
+    @db.add( record)
+    assert( File.exist?('rec.yml') )
+    loaded = YAML.load( File.open('rec.yml','r') )
+    rec2 = record.dup
+    rec2[:id] = 1
+    assert_equal( rec2, loaded[0])
+
+    assert_raise(RuntimeError) {
+      @db.transaction do
+        @db.add( {:key1 => 99, :key2 => 2} )
+        raise
+      end
+    }
+    loaded2 = YAML.load( File.open('rec.yml','r') )
+    assert_equal( loaded, loaded2)
+  end
+
   def test_create_table
     assert_nil( NERA::Database.create_table( @path_to_db) )
   end

data/test/test_nera_db_folders.rb

@@ -210,5 +210,13 @@ class TC_NERA_DB_FOLDERS < Test::Unit::TestCase
     assert_equal( @db_folder+"/Tables/hosts.yml",p)
   end
 
+  def test_logger
+    @dbf.logger.info("controller") do "test_message" end
+    assert( File.exist?( @db_folder+"/Tables/logfile.txt") )
+    last_line = File.open(  @db_folder+"/Tables/logfile.txt", 'r').readlines[-1]
+    assert( last_line =~ /^I,/)
+    assert( last_line =~ /controller: test_message$/)
+  end
+
 end
   

data/test/test_nera_job_layer_controller.rb

@@ -55,11 +55,16 @@ class TC_NERA_JOB_LAYER_CONTROLLER < Test::Unit::TestCase
       @jlc.cancel_jobs(1)
     }
 
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     f = @jlc.cancel_jobs( [1,2] )
     assert_equal([1,2], f)
     h, l = @jlc.not_finished_list_in_csv
     assert_equal( 1, l.size)
     assert_equal( 3, l[0].split(',')[0].to_i)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+2, s2)
+
 
     flag = File.exist?( @dbf.path_to_job_script(1))
     assert_equal( false, flag)
@@ -71,9 +76,15 @@ class TC_NERA_JOB_LAYER_CONTROLLER < Test::Unit::TestCase
 
     f = @jlc.cancel_jobs( [1000] )
     assert_nil( f)
+    s3 = File.open(logp,'r').readlines.size
+    assert_equal( s2, s3)
+
 
     f = @jlc.cancel_jobs( [2,3] )
     assert_equal( [3], f)
+    s4 = File.open(logp,'r').readlines.size
+    assert_equal( s3+1, s4)
+
   end
 
   def test_include_list
@@ -93,9 +104,15 @@ class TC_NERA_JOB_LAYER_CONTROLLER < Test::Unit::TestCase
   def test_include
     prepare_zipped_file
     fname = "j000001.tar.bz2"
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
+
     @jlc.include(fname)
     f = FileTest.exist?(fname)
     assert_equal( false, f)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1, s2)
+
     count = 0
     File.open( @dbf.path_to_finished_jobs_file, 'r') do |io|
       YAML.load_documents( io) do |doc|
@@ -112,6 +129,9 @@ class TC_NERA_JOB_LAYER_CONTROLLER < Test::Unit::TestCase
 
   def test_include_all
     prepare_zipped_file
+
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     @jlc.include_all
     a = Dir.glob( @dbf.path_to_include_layer + "*" )
     assert_equal( [], a)
@@ -119,6 +139,8 @@ class TC_NERA_JOB_LAYER_CONTROLLER < Test::Unit::TestCase
     assert_equal( [], l)
     h, l = @rlc.not_finished_jobs_list_in_csv
     assert_equal( [], l)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+3, s2)
   end
 
   def prepare_zipped_file

data/test/test_nera_job_records.rb

@@ -27,6 +27,19 @@ class TC_NERA_JOB_RECS < Test::Unit::TestCase
     assert_nil( f)
   end
 
+  def test_set_yaml_file
+    @db.set_yaml_file( 'jobs.yml')
+    assert( ! File.exist?( 'jobs.yml') )
+
+    given_id = @db.add( Ising,5,3,4 )
+    assert( File.exist?( 'jobs.yml') )
+    loaded = YAML.load( File.open('jobs.yml','r') )
+
+    given_id = @db.add( XY,4,2,5 )
+    loaded2 = YAML.load( File.open('jobs.yml','r') )
+    assert( loaded.size < loaded2.size )
+  end
+
   def test_keys
     k = [ :id,:state,:simulator,:parameter_id,:run_id,
           :number_of_runs,:created_at,:updated_at,:host_name ]

data/test/test_nera_parameter_layer_controller.rb

@@ -93,8 +93,12 @@ class TC_NERA_PARAM_LAYER_CONTROLLER < Test::Unit::TestCase
   end
 
   def test_create_a_new_parameter_set
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     f = @plc.create_a_new_parameter_set( {:L => 32, :K => 0.01, :tmax => 1} )
     assert_equal( 1, f)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1, s2)
     f = @plc.create_a_new_parameter_set( {:L => 64, :K => 0.02} )
     assert_equal( 2, f)
     f = @plc.create_a_new_parameter_set( {:L => 96, :tmax => 3} )
@@ -120,8 +124,12 @@ class TC_NERA_PARAM_LAYER_CONTROLLER < Test::Unit::TestCase
 
   def test_move_a_parameter_set_into_trashbox
     add_three
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     f = @plc.move_a_parameter_set_into_trashbox(2)
     assert_equal( true, f)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1,s2)
     header, list = @plc.parameters_list_in_csv
     assert_equal( 2, list.size)
     f = @plc.move_a_parameter_set_into_trashbox(2)
@@ -148,8 +156,12 @@ class TC_NERA_PARAM_LAYER_CONTROLLER < Test::Unit::TestCase
     add_three
     h_org, l_org = @plc.parameters_list_in_csv
     f = @plc.move_a_parameter_set_into_trashbox(2)
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     f = @plc.revert_a_parameter_set_in_trashbox(2)
     assert(f)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1, s2)
     h2, l2 = @plc.parameters_list_in_csv
     assert_equal( l_org, l2)
     h3, l3 = @plc.trashbox_parameter_list_in_csv
@@ -169,8 +181,12 @@ class TC_NERA_PARAM_LAYER_CONTROLLER < Test::Unit::TestCase
     add_three
     h_org, l_org = @plc.parameters_list_in_csv
     @plc.move_a_parameter_set_into_trashbox(2)
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     s = @plc.delete_a_parameter_set(2)
     assert(s)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1, s2)
     ht, lt = @plc.trashbox_parameter_list_in_csv
     assert_equal( [], lt)
     

data/test/test_nera_parameter_records.rb

@@ -7,9 +7,13 @@ class TC_NERA_PARAM_RECS < Test::Unit::TestCase
     @testdir = 'test_sim_recs'
     FileUtils.mkdir(@testdir)
     FileUtils.chdir(@testdir)
-    @path_to_db = 'sim_recs_table.marshal'
+    @path_to_db_sim = 'sim_recs_table.marshal'
+    @path_to_db = 'param_recs_table.marshal'
+    NERA::SimulatorRecords.create_table( @path_to_db_sim)
+    @s_db = NERA::SimulatorRecords.new( @path_to_db_sim)
+    id = @s_db.add(Ising)
     NERA::ParameterRecords.create_table( @path_to_db, Ising)
-    @db = NERA::ParameterRecords.new( @path_to_db, Ising)
+    @db = NERA::ParameterRecords.new( @path_to_db, @s_db, id)
   end
 
   def teardown
@@ -18,14 +22,17 @@ class TC_NERA_PARAM_RECS < Test::Unit::TestCase
   end
   
   def test_initialize
-    assert_raise( RuntimeError) {
-      NERA::ParameterRecords.new('unknown_file', Ising)
+    assert_raise( ArgumentError) {
+      NERA::ParameterRecords.new('unknown_file', Ising, "1")
+    }
+    assert_raise( ArgumentError) {
+      NERA::ParameterRecords.new('unknown_file', Ising, 1)
     }
     assert_raise( ArgumentError) {
-      NERA::ParameterRecords.new( @path_to_db, XY)
+      NERA::ParameterRecords.new( @path_to_db, XY, 1)
     }
     assert_raise( ArgumentError) {
-      NERA::ParameterRecords.new(@path_to_db, Temp)
+      NERA::ParameterRecords.new(@path_to_db, Temp, 1)
     }
   end
 
@@ -42,6 +49,46 @@ class TC_NERA_PARAM_RECS < Test::Unit::TestCase
     }
   end
 
+  def test_observer
+    @s_db.add(XY)
+
+    d1 = @s_db.list[0][:updated_at]
+    dx1 = @s_db.list[1][:updated_at]
+    sleep 2
+    param1 = { :L => 32, :K => 0.22, :tmax => 512 }
+    f = @db.add( param1)
+    d2 = @s_db.list[0][:updated_at]
+    dx2 = @s_db.list[1][:updated_at]
+    assert( d1 < d2)
+    assert_equal( dx1, dx2)
+
+    sleep 2
+    @db.transaction do
+      @db.update_to_state_trashbox(1)
+      d3 = @s_db.list[0][:updated_at]
+      assert_equal( d2, d3)
+    end
+    d4 = @s_db.list[0][:updated_at]
+    dx3 = @s_db.list[1][:updated_at]
+    assert( d2 < d4)
+    assert_equal( dx1, dx3)
+  end
+
+  def test_set_yaml_file
+    @db.set_yaml_file( 'parameters.yml')
+    assert( ! File.exist?( 'parameters.yml') )
+
+    param1 = { :L => 32, :K => 0.22, :tmax => 512 }
+    f = @db.add( param1)
+    assert( File.exist?( 'parameters.yml') )
+    loaded = YAML.load( File.open('parameters.yml','r') )
+
+    sleep 2
+    @db.touch(f)
+    loaded2 = YAML.load( File.open('parameters.yml','r') )
+    assert( loaded[0][:updated_at] < loaded2[0][:updated_at] )
+  end
+
   def test_keys
     assert_equal( [:id,:created_at,:updated_at,:in_trashbox?,:L,:K,:tmax], @db.keys)
   end
@@ -232,7 +279,7 @@ class TC_NERA_PARAM_RECS < Test::Unit::TestCase
   def test_touch
     add_three
     a = @db.find_by_id(1)
-    sleep 3
+    sleep 2
     f = @db.touch( 1)
     assert_equal(true, f)
     b = @db.find_by_id(1)
@@ -244,6 +291,21 @@ class TC_NERA_PARAM_RECS < Test::Unit::TestCase
     assert_nil( f)
   end
 
+  def test_update
+    add_three
+    a = @db.find_by_id(1)
+    sleep 2
+    f = @db.update( 1)
+    assert_equal(true, f)
+    b = @db.find_by_id(1)
+    assert( a[:updated_at] < b[:updated_at] )
+    b[:updated_at] = a[:updated_at]
+    assert_equal( a, b)
+    
+    f = @db.update(500)
+    assert_nil( f)
+  end
+
   def test_destroy
     add_three
     @db.update_to_state_trashbox(3)

data/test/test_nera_remote_connector.rb

@@ -68,17 +68,27 @@ class TC_NERA_RM_CONNECTOR < Test::Unit::TestCase
       @rc.transfer( [1,2], 1)
     }
     
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     ret = @rc.transfer( [999,1000], "localhost")
     assert_equal( :no_such_jobs, ret)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1, s2)
+
 
     ret = @rc.transfer( [1,2], "unknown_host")
     assert_equal( :connection_failed, ret)
 
     ret = @rc.transfer( [1], "unconnectable")
     assert_equal( :connection_failed, ret)
+    s3 = File.open(logp,'r').readlines.size
+    assert_equal( s2+1, s3)
 
     ret = @rc.transfer( [1,2], "localhost")
     assert_equal( :succeeded, ret)
+    s3 = File.open(logp,'r').readlines.size
+    assert_equal( s2+3, s3)
+
     h,l = @jlc.not_finished_list_in_csv
     stat = l[0].split(',')[1].strip
     assert_equal( :copied.to_s, stat)
@@ -120,11 +130,17 @@ class TC_NERA_RM_CONNECTOR < Test::Unit::TestCase
     ret = @rc.submit( [1,2], "unknown_host")
     assert_equal( :connection_failed, ret)
 
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     ret = @rc.submit( [1], "unconnectable")
     assert_equal( :connection_failed, ret)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1, s2)
 
     ret = @rc.submit( [1,2], "localhost_submittable")
     assert_equal( :succeeded, ret)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+3, s2)
 
     h,l = @jlc.not_finished_list_in_csv
     stat = l[0].split(',')[1].strip
@@ -198,17 +214,26 @@ class TC_NERA_RM_CONNECTOR < Test::Unit::TestCase
     ret = @rc.download( ["j000001.tar.bz2"], "unknown_host")
     assert_equal( :connection_failed, ret)
 
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     ret = @rc.download( ["j000001.tar.bz2"], "unconnectable")
     assert_equal( :connection_failed, ret)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1,s2)
 
     ret = @rc.download( ["j000001.tar.bz2"], "localhost_submittable")
     assert_equal( [], ret)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1,s2)
 
     ret = @rc.submit( [1,2], "localhost_submittable")
     sleep 3 # wait for completion
     downloadable = @rc.check_completion("localhost_submittable")
     ret = @rc.download( downloadable, "localhost_submittable")
     assert_equal( ["j000001.tar.bz2", "j000002.tar.bz2"], ret)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+5,s2)
+
 
     downloadable = @rc.check_completion("localhost_submittable")
     assert_equal( downloadable, [])

data/test/test_nera_run_layer_controller.rb

@@ -73,11 +73,16 @@ class TC_NERA_RUN_LAYER_CONTROLLER < Test::Unit::TestCase
   end
 
   def test_create_jobs
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
+
     jid = @rlc.create_jobs(1)
     header, list = @rlc.all_runs_list_in_csv
     assert_equal( 1, list.size)
     assert_equal( [1], jid)
     assert( list[0].split(', ')[3].to_i > 0) # check job id
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1,s2)
 
     jobs_table = NERA::JobRecords.new( @dbf.path_to_jobs_table)
     l = jobs_table.list_all
@@ -87,6 +92,9 @@ class TC_NERA_RUN_LAYER_CONTROLLER < Test::Unit::TestCase
 
     # -------------------------------------
     jid = @rlc.create_jobs(3)
+    s3 = File.open(logp,'r').readlines.size
+    assert_equal( s2+3,s3)
+
     header, list = @rlc.all_runs_list_in_csv
     assert_equal( 4, list.size)
     assert_equal( [2,3,4], jid)
@@ -107,6 +115,9 @@ class TC_NERA_RUN_LAYER_CONTROLLER < Test::Unit::TestCase
     header, list = @rlc.all_runs_list_in_csv
     assert_equal( 8, list.size)
     assert_equal( [5,6], jid)
+    s4 = File.open(logp,'r').readlines.size
+    assert_equal( s3+2,s4)
+
 
     jobs_table = NERA::JobRecords.new( @dbf.path_to_jobs_table)
     l = jobs_table.list_all
@@ -139,10 +150,15 @@ class TC_NERA_RUN_LAYER_CONTROLLER < Test::Unit::TestCase
   def test_cancel_jobs
     jids = @rlc.create_jobs(3)
     p jids
+
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
     canceled = @rlc.cancel_jobs( jids)
     assert_equal( jids, canceled)
     h, l = @rlc.all_runs_list_in_csv
     assert_equal( 0, l.size)
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+3, s2)
 
     l = NERA::JobRecords.new( @dbf.path_to_jobs_table).list_all
     assert_equal( 0, l.size)
@@ -165,16 +181,27 @@ class TC_NERA_RUN_LAYER_CONTROLLER < Test::Unit::TestCase
   end
 
   def test_analyze
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
+
     @rlc.analyze( "analyze_test1")
     assert( FileTest.exist?( @dbf.path_to_run_layer(Ising,1) + "test1") )
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+1, s2)
 
     assert_nil( @rlc.analyze( "hoge") )
   end
 
   def test_analyze_all
+    logp = @db_folder+'/Tables/logfile.txt'
+    s1 = File.open(logp,'r').readlines.size
+
     @rlc.analyze_all
     assert( FileTest.exist?( @dbf.path_to_run_layer(Ising,1) + "test1") )
     assert( FileTest.exist?( @dbf.path_to_run_layer(Ising,1) + "test2") )
+    s2 = File.open(logp,'r').readlines.size
+    assert_equal( s1+2, s2)
+
   end
   
 end

data/test/test_nera_run_records.rb

@@ -8,8 +8,20 @@ class TC_NERA_RUN_RECORDS < Test::Unit::TestCase
     FileUtils.mkdir( @testdir)
     FileUtils.chdir( @testdir)
     @table_file = 'run_recs.pstore'
+
+    @path_to_db_sim = 'sim_recs_table.marshal'
+    @path_to_db_param = 'param_recs_table.marshal'
+    NERA::SimulatorRecords.create_table( @path_to_db_sim)
+    @s_recs = NERA::SimulatorRecords.new( @path_to_db_sim)
+    id = @s_recs.add( Ising)
+    NERA::ParameterRecords.create_table( @path_to_db_param, Ising)
+    @p_recs = NERA::ParameterRecords.new( @path_to_db_param, @s_recs, id)
+    param1 = { :L => 32, :K => 0.22, :tmax => 512 }
+    f = @p_recs.add( param1)
+
+
     NERA::RunRecords.create_table( @table_file)
-    @rrecs = NERA::RunRecords.new( @table_file)
+    @rrecs = NERA::RunRecords.new( @table_file, @p_recs, f)
   end
 
   def teardown
@@ -19,10 +31,52 @@ class TC_NERA_RUN_RECORDS < Test::Unit::TestCase
 
   def test_initialize
     assert_raise( RuntimeError) {
-      NERA::RunRecords.new( 'unknown')
+      NERA::RunRecords.new( 'unknown', @p_recs, 1)
+    }
+    assert_raise( ArgumentError) {
+      NERA::RunRecords.new( @table_file, Ising, 1)
+    }
+    assert_raise( ArgumentError) {
+      NERA::RunRecords.new( @table_file, @p_recs, '1')
     }
   end
 
+  def test_observer
+    @s_recs.add(XY)
+    @p_recs.add( { :L => 64, :K => 0.25, :tmax => 512 })
+
+    da1 = @s_recs.list[0][:updated_at]
+    db1 = @s_recs.list[1][:updated_at]
+    dc1 = @p_recs.list_all[0][:updated_at]
+    dd1 = @p_recs.list_all[1][:updated_at]
+    sleep 2
+
+    @rrecs.add(1)
+    de1 = @s_recs.list[0][:updated_at]
+    df1 = @s_recs.list[1][:updated_at]
+    dg1 = @p_recs.list_all[0][:updated_at]
+    dh1 = @p_recs.list_all[1][:updated_at]
+    assert( da1 < de1)
+    assert( dc1 < dg1)
+    assert_equal( db1, df1)
+    assert_equal( dd1, dh1)
+  end
+
+  def test_set_yaml_file
+    @rrecs.set_yaml_file( 'runs.yml')
+    assert( ! File.exist?( 'runs.yml') )
+
+    @rrecs.add( 1)
+    assert( File.exist?( 'runs.yml') )
+    loaded = YAML.load( File.open('runs.yml','r') )
+
+    sleep 2
+    @rrecs.add(1)
+    loaded2 = YAML.load( File.open('runs.yml','r') )
+    assert( loaded.size < loaded2.size )
+  end
+
+
   def test_create_a_new_table
     n = NERA::RunRecords.create_table( @table_file)
     assert_nil(n)