require File.dirname(__FILE__) + '/test_helper'


class TC_NERA_RUN_RECORDS < Test::Unit::TestCase

  def setup
    @testdir = 'test_run_recs'
    FileUtils.mkdir( @testdir)
    FileUtils.chdir( @testdir)
    @table_file = 'run_recs.pstore'
    NERA::RunRecords.create_table( @table_file)
    @rrecs = NERA::RunRecords.new( @table_file)
  end

  def teardown
    FileUtils.chdir('..')
    FileUtils.rm_r( @testdir)
  end

  def test_initialize
    assert_raise( RuntimeError) {
      NERA::RunRecords.new( 'unknown')
    }
  end

  def test_create_a_new_table
    n = NERA::RunRecords.create_table( @table_file)
    assert_nil(n)
    
    n = NERA::RunRecords.create_table('hoge')
    assert( File.exist?('hoge') )
    assert_equal( true, n)
  end

  def test_keys
    a = [ [:id, Integer], [:state, Symbol], [:created_at, DateTime],
          [:job_id, Integer], [:seed, Integer], 
          [:start_at, DateTime], [:finish_at, DateTime], 
          [:included_at, DateTime], [:real_time, Float], 
          [:user_time, Float], [:host_name, String], 
          [:omp_threads, Integer], [:mpi_processes, Integer]
        ]
    k = a.map do |x| x[0] end
    assert_equal( k, @rrecs.keys)
  end

  def test_add
    r = @rrecs.add( 1)
    l = @rrecs.list_all
    lf = @rrecs.list_all_finished
    ln = @rrecs.list_all_not_finished
    assert_equal( 1, r.size)
    assert_equal( r[0][:id], 1)
    assert( r[0][:seed] > 0 )
    assert_equal( r[0][:omp_threads], 1)
    assert_equal( r[0][:mpi_processes], 1)
    assert_equal( 1, l.size)
    assert_equal( 0, lf.size)
    assert_equal( 1, ln.size)

    r = @rrecs.add( 99)
    a = @rrecs.list_all
    assert_equal( 99, r.size)
    assert_equal( 100, a.size)
    
    r = @rrecs.add( 20)
    a = @rrecs.list_all
    assert_equal( 20, r.size)
    assert_equal( 120, a.size)
    f = a.find do |r| r[:id] == 120 end
    assert( f)
  end

  def test_set_job_id
    r = @rrecs.add( 10)
    id = r[0][:id]
    jid = @rrecs.set_job_id( id, 10, 1)
    assert_equal( 1, jid)
    r = @rrecs.add( 10)
    id = r[0][:id]
    assert_raise( RuntimeError) {
      @rrecs.set_job_id( id, 11, 1)
    }
    assert_raise( RuntimeError) {
      @rrecs.set_job_id( 21, 1, 1)
    }
    assert_raise( ArgumentError) {
      @rrecs.set_job_id( 11, 1, "1")
    }
    assert_raise( ArgumentError) {
      @rrecs.set_job_id( "11", 1, 1)
    }
    assert_raise( ArgumentError) {
      @rrecs.set_job_id( 11, "1", 1)
    }
    jid = @rrecs.set_job_id(11,10,2)
    assert_raise( RuntimeError) {
      @rrecs.set_job_id(11,10,2)
    }

    l = @rrecs.list_all
    l.find_all do |x|
      x[:job_id] == 1
    end
    assert_equal( 20, l.size)
    k = l.find_all do |x|
      x[:job_id] == 2
    end
    assert_equal( 10, k.size)
  end

  def test_list
    l = @rrecs.list_all
    lf = @rrecs.list_all_finished
    ln = @rrecs.list_all_not_finished
    assert( l.is_a?(Array))
    assert( lf.is_a?(Array))
    assert( ln.is_a?(Array))
    assert_equal( 0, l.size)
    assert_equal( 0, lf.size)
    assert_equal( 0, ln.size)
    
    @rrecs.add( 5)
    l = @rrecs.list_all
    lf = @rrecs.list_all_finished
    ln = @rrecs.list_all_not_finished
    assert_equal( 5, l.size)
    assert_equal( 0, lf.size)
    assert_equal( 5, ln.size)
    5.times do |i|
      assert( l[i].is_a?(Hash) )
      assert_equal( 0, (l[i].keys - @rrecs.keys).size)
      assert_equal( 0, (ln[i].keys - @rrecs.keys).size)
    end

    @rrecs.update_state_to_finished( 1, DateTime.now, DateTime.now, DateTime.now, 0.5, 0.5, "host_hoge")
    @rrecs.update_state_to_finished( 2, DateTime.now, DateTime.now, DateTime.now, 0.5, 0.5, "host_hoge")
    l2 = @rrecs.list_all
    lf = @rrecs.list_all_finished
    ln = @rrecs.list_all_not_finished
    assert_equal( 5, l2.size)
    assert_equal( 2, lf.size)
    assert_equal( 3, ln.size)
    found1 = l.find do |r| r[:id] == 3 end
    found2 = l2.find do |r| r[:id] == 3 end
    assert_equal( found1, found2)
    found1 = l.find do |r| r[:id] == 4 end
    found2 = l2.find do |r| r[:id] == 4 end
    assert_equal( found1, found2)
    found1 = l.find do |r| r[:id] == 5 end
    found2 = l2.find do |r| r[:id] == 5 end
    assert_equal( found1, found2)
    
    2.times do |i|
      assert( lf[i].is_a?(Hash) )
      assert_equal( 0, (lf[i].keys - @rrecs.keys).size)
    end

    found = lf.find do |rec|
      rec[:id] == 3
    end
    assert_nil( found)
    found = lf.find do |rec|
      rec[:id] == 2
    end
    assert(found)

    d = @rrecs.destroy( 4)
    assert( d)
    l = @rrecs.list_all
    lf = @rrecs.list_all_finished
    ln = @rrecs.list_all_not_finished
    assert_equal( 4, l.size)
    assert_equal( 2, lf.size)
    assert_equal( 2, ln.size)
  end

  def test_update_state_to_finished
    r = @rrecs.add( 10)
    id = r[0][:id]
    jid = @rrecs.set_job_id( id, 10, 1)
    l = @rrecs.list_all_not_finished
    assert( 10, l.size)

    d = DateTime.now
    @rrecs.update_state_to_finished( 1, d, d, d, 0.5, 0.5, "acp1")
    l = @rrecs.list_all_not_finished
    assert( 9, l.size)
    lf = @rrecs.list_all_finished
    assert( 1, lf.size)
    p lf[0]
    assert_equal( 1, lf[0][:id])
    assert_equal( d, lf[0][:start_at])
    assert_equal( d, lf[0][:finish_at])
    assert_equal( d, lf[0][:included_at])
    assert_equal( 0.5, lf[0][:real_time])
    assert_equal( 0.5, lf[0][:user_time])
    assert_equal( "acp1", lf[0][:host_name])
    assert_equal( :finished, lf[0][:state])
    n = @rrecs.update_state_to_finished( 1, d, d, d, 0.5, 0.5, "acp1")
    assert_nil( n)

    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( "1", DateTime.now, DateTime.now, DateTime.now, 0.5, 0.5, "acp1")
    }
    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( 1, "08-25-12", DateTime.now, DateTime.now, 0.5, 0.5, "acp1")
    }
    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( 1, DateTime.now, "08-25-12", DateTime.now, 0.5, 0.5, "acp1")
    }
    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( 1, DateTime.now, DateTime.now, "08-25-12", 0.5, 0.5, "acp1")
    }
    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( 1, DateTime.now, DateTime.now, DateTime.now, 5, 0.5, "acp1")
    }
    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( 1, DateTime.now, DateTime.now, DateTime.now, 0.5, 5, "acp1")
    }
    assert_raise( ArgumentError) {
      @rrecs.update_state_to_finished( 1, DateTime.now, DateTime.now, DateTime.now, 0.5, 0.5, 13)
    }
    
    n = @rrecs.update_state_to_finished( 11, d, d, d, 0.5, 0.5, "acp1")
    assert_nil( n)
  end

  def test_destroy
    r = @rrecs.add( 10)
    id = r[0][:id]
    jid = @rrecs.set_job_id( id, 10, 1)

    rec = @rrecs.destroy( 1)
    assert( rec.is_a?(Hash))
    assert_equal(1, rec[:id])
    assert_equal(:not_finished, rec[:state])
    assert_equal(jid, rec[:job_id])
    rec = @rrecs.destroy( 1)
    assert_nil(nil)
    assert_equal( 9, @rrecs.list_all.size)

    d = DateTime.now
    @rrecs.update_state_to_finished( 2, d, d, d, 0.5, 0.5, "acp1")
    rec = @rrecs.destroy( 2)
    assert_nil(rec)
    assert_equal(9, @rrecs.list_all.size)
  end

  def test_destroy_job_id
    r = @rrecs.add(2)
    id = r[0][:id]
    jid = @rrecs.set_job_id( id, 2, 1)

    f = @rrecs.destroy_job_id(1)
    assert(f)
    assert_equal( 0, @rrecs.list_all.size)
    f = @rrecs.destroy_job_id(1)
    assert_nil(f)

    r = @rrecs.add(1)
    id = r[0][:id]
    jid = @rrecs.set_job_id( id, 1, 2)
    d = DateTime.now
    @rrecs.update_state_to_finished( 3, d, d, d, 0.5, 0.5, "acp1")
    f = @rrecs.destroy_job_id(2)
    assert_nil(f)
  end

  def test_transaction
    r = @rrecs.add( 10)
    id = r[0][:id]
    jid = @rrecs.set_job_id( id, 10, 1)
    l = @rrecs.list_all_not_finished
    assert( 10, l.size)

    assert_raise(RuntimeError) {
      @rrecs.transaction {
        d = DateTime.now
        @rrecs.update_state_to_finished(1,d,d,d,0.5,0.5,"hoge")
        assert( 9, @rrecs.list_all_not_finished)
        raise
      }
    }
    l2 = @rrecs.list_all_not_finished
    assert_equal( l, l2)
    assert_equal( 10, l2.size)
  end

end