rbatch 1.13.0 → 1.13.1

data/Rakefile

@@ -1,5 +1,4 @@
 require "bundler/gem_tasks"
-require 'rake/rdoctask'
 
 desc "Test lib/ by using test/cases/test_*.rb"
 task :test do
@@ -28,11 +27,6 @@ task :test do
   end
 end
 
-Rake::RDocTask.new do |rd|
-  rd.rdoc_dir = 'rdocs'
-  rd.rdoc_files = FileList["lib/**/*.rb"]
-  rd.options << '-charset=UTF-8 '
-end
 
 desc "Test, Make RDoc, Release"
 task :all => [:test, :rdoc, :release]

data/lib/rbatch/cmd.rb

@@ -1,5 +1,6 @@
 require 'fileutils'
 require 'tempfile'
+require 'tmpdir'
 
 module RBatch
 
@@ -8,26 +9,25 @@ module RBatch
   #This module is a wrapper of Kernel#spawn.
   #
   # * Arguments(cmd_params) are inputed to Kernel#spawn directly and run command.
-  # * Command's stdout and stderr is written to tmp file.
-  #  * If Platform is "mswin" or "mingw" , then temp directory is ENV["TEMP"]
-  #  * If Platform is "linux" or "cygwin" , then temp directory is "/tmp/"
   # * Return an object of RBatch::CmdResult which includes stdout, stderr, and exit status.
   #
   # ==== Sample 1
   #  require 'rbatch'
-  #  cmd = RBatch::Cmd("ls")
-  #  r = cmd.run
-  #  p r.stdout
+  #  result = RBatch::cmd("ls")
+  #  p result.stdout
   #  => "fileA\nfileB\n"
   #
-  # ==== Sample 2 ( Use option)
-  #  cmd = RBatch::Cmd("ls", {:verbose => true})
-  #  r = cmd.run
+  # ==== Sample 2 (use option)
+  #  require 'rbatch'
+  #  result = RBatch::cmd("ls",{:timeout => 1})
+  #  p result.stdout
+  #  => "fileA\nfileB\n"
   #
-  # ==== Sample 3 ( Use alias)
+  # ==== Sample 3 (use instance)
   #  require 'rbatch'
-  #  r = RBatch::cmd("ls")
-  #  p r.stdout
+  #  cmd = RBatch::Cmd.new("ls")
+  #  result = cmd.run
+  #  p result.stdout
   #  => "fileA\nfileB\n"
   #
   class Cmd
@@ -69,16 +69,16 @@ module RBatch
     # ==== Return
     # instance of RBatch::CmdResult
     def run()
-      stdout_file = Tempfile::new("rbatch_tmpout",RBatch::tmp_dir)
-      stderr_file = Tempfile::new("rbatch_tmperr",RBatch::tmp_dir)
+      stdout_file = Tempfile::new("rbatch_tmpout",Dir.tmpdir)
+      stderr_file = Tempfile::new("rbatch_tmperr",Dir.tmpdir)
       pid = spawn(@cmd_str,:out => [stdout_file,"w"],:err => [stderr_file,"w"])
       if @opt[:timeout] != 0
-        timeout(@opt[:timeout]) do
-          begin
+        begin
+          timeout(@opt[:timeout]) do
             status =  Process.waitpid2(pid)[1] >> 8
-          rescue Timeout::Error => e
-            raise(CmdException,"Command timeout (over " + @opt[:timeout] + " sec)" )
           end
+        rescue Timeout::Error => e
+          raise(CmdException,"Command timeout. Runtime is over " + @opt[:timeout].to_s + " sec. Command is " + @cmd_str )
         end
       else
         status =  Process.waitpid2(pid)[1] >> 8

data/lib/rbatch/version.rb

@@ -1,3 +1,3 @@
 module RBatch
-  VERSION = "1.13.0"
+  VERSION = "1.13.1"
 end

data/lib/rbatch.rb

@@ -1,88 +1,70 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
 require 'digest'
+require 'yaml'
 module RBatch
-  @@program_name = $PROGRAM_NAME
-  @@home_dir = ""
+  @@opt = {}
+  @@rbatch_config = nil
   module_function
-  def program_name=(f) ; @@program_name = f ; end
-  def program_name ; @@program_name ; end
-  def home_dir=(d) ; @@home_dir = d ; end
-  def home_dir ; @@home_dir ; end
-
-  # Hostname
-  def hostname
+  def program_name       ; @@opt[:program_name] ; end
+  def home_dir           ; @@opt[:home_dir] ; end
+  def home_dir=(d)       ; @@opt[:home_dir]=d ; end
+  def hostname           ; @@opt[:hostname] ; end
+  def rbatch_config      ; @@rbatch_config ; end
+  def opt                ; @@opt ; end
+  def init
+    @@opt[:program_name] = $PROGRAM_NAME
+    @@opt[:home_dir] = ENV["RB_HOME"] ? ENV["RB_HOME"] : File.join(File.dirname(@@opt[:program_name]) , "..")
     case RUBY_PLATFORM
     when /mswin|mingw/
-      return ENV["COMPUTERNAME"] ? ENV["COMPUTERNAME"] : "unknownhost"
+      @@opt[:hostname] =  ENV["COMPUTERNAME"] ? ENV["COMPUTERNAME"] : "unknownhost"
     when /cygwin|linux/
-      return ENV["HOSTNAME"] ? ENV["HOSTNAME"] : "unknownhost"
+      @@opt[:hostname] = ENV["HOSTNAME"] ? ENV["HOSTNAME"] : "unknownhost"
     else
-      return "unknownhost"
-    end
-  end
-  # tmp dir
-  def tmp_dir
-    case RUBY_PLATFORM
-    when /mswin|mingw/
-      if ENV["TEMP"].nil?
-        raise "Cannot use temporary directory, because ENV[\"TEMP\"] is not defined"
-      else
-        return ENV["TEMP"]
-      end
-    when /cygwin|linux/
-      return ENV["TMPDIR"] ? ENV["TMPDIR"] : "/tmp"
-    else
-      if ENV["TMPDIR"].nil? && ENV["TEMP"].nil?
-        raise "Unknown RUBY_PRATFORM : " + RUBY_PLATFORM
-      else
-        return ENV["TMPDIR"] || ENV["TEMP"]
-      end
+      @@opt[:hostname] = "unknownhost"
     end
+    load_rbatch_config
   end
   def rbatch_config_path
-    File.join(@@home_dir,"conf","rbatch.yaml")
+    File.join(@@opt[:home_dir],"conf","rbatch.yaml")
+  end
+  def config_dir
+    File.join(RBatch.home_dir,"conf")
   end
-  def rbatch_config
-    if File.exist?(RBatch.rbatch_config_path)
-      yaml = YAML::load_file(RBatch.rbatch_config_path)
-      if yaml
-        return yaml
-      else
-        # If file is emply , YAML::load_file is false
-        return nil
+  def log_dir
+    File.join(RBatch.home_dir,"log")
+  end
+  def load_rbatch_config
+    if File.exist?(rbatch_config_path)
+      @@rbatch_config = YAML::load_file(rbatch_config_path)
+      if @@rbatch_config == false
+        @@rbatch_config = nil
       end
     else
-      return nil
+      @@rbatch_config = nil
     end
   end
   def double_run_check
     # double run check
-    if ( RBatch::rbatch_config != nil && RBatch::rbatch_config["forbid_double_run"] )
-      lock_file="rbatch_lock_" + Digest::MD5.hexdigest(@@program_name)
-      if Dir.exists? RBatch::tmp_dir
-        Dir::foreach(RBatch::tmp_dir) do |f|
+    if ( @@rbatch_config != nil && @@rbatch_config["forbid_double_run"] )
+      lock_file="rbatch_lock_" + Digest::MD5.hexdigest(@@opt[:program_name])
+      if Dir.exists? @@opt[:tmp_dir]
+        Dir::foreach(@@opt[:tmp_dir]) do |f|
           if (Regexp.new(lock_file) =~ f)
-            raise RBatchException, "Script double run is forbid about \"#{RBatch::program_name}\""
+            raise RBatchException, "Script double run is forbid about \"#{@@opt[:program_name]}\""
           end
         end
       end
       # make lockfile
-      Tempfile::new(lock_file,RBatch::tmp_dir)
+      Tempfile::new(lock_file,@@opt[:tmp_dir])
     end
   end
-
-  def double_run_lock_file ;  ; end
 end
 
 # RBatch Exception
 class RBatchException < Exception ; end
 
 # main
-if ENV["RB_HOME"]
-  RBatch::home_dir = ENV["RB_HOME"]
-else
-  RBatch::home_dir = File.join(File.dirname(RBatch.program_name) , "..")
-end
+RBatch::init
 
 require 'rbatch/log'
 require 'rbatch/config'

data/spec/cmd_test.spec

@@ -0,0 +1,127 @@
+require 'tmpdir'
+ENV["RB_HOME"]=Dir.tmpdir
+
+require 'rbatch'
+
+describe RBatch::Cmd do
+
+  it "run command which status is 0" do
+    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'"
+    expect(result.stdout.chomp).to eq "1"
+    expect(result.stderr.chomp).to eq "2"
+    expect(result.status).to eq 0
+  end
+  it "run command which status is 1" do
+    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
+    expect(result.stdout.chomp).to eq "1"
+    expect(result.stderr.chomp).to eq "2"
+    expect(result.status).to eq 1
+  end
+  it "raise error when command does not exist" do
+    expect {
+      RBatch::cmd "not_exist_command"
+    }.to raise_error(Errno::ENOENT)
+  end
+  it "run command which stdout size is greater than 65534byte" do
+    result = RBatch::cmd "ruby -e '100000.times{print 0}'"
+    expect(result.stdout.chomp.size).to eq 100000
+    expect(result.stderr.chomp).to eq ""
+    expect(result.status).to eq 0
+  end
+  it "run command which stdout size is greater than 65534bytes with status 1" do
+    result = RBatch::cmd "ruby -e '100000.times{print 0}; exit 1'"
+    expect(result.stdout.chomp.size).to eq 100000
+    expect(result.stderr.chomp).to eq ""
+    expect(result.status).to eq 1
+  end
+  it "run command which status is grater than 256" do
+    result = RBatch::cmd  "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 300;'"
+    expect(result.stdout.chomp).to eq "1"
+    expect(result.stderr.chomp).to eq "2"
+    case RUBY_PLATFORM
+    when /mswin|mingw/
+      expect(result.status).to eq 300
+    when /cygwin|linux/
+      # windos platform can not handle result code as modular 256
+      expect(result.status).to eq 44
+    end
+  end
+  it "run to_h method" do
+    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
+    expect(result.to_h[:stdout]).to eq "1"
+    expect(result.to_h[:stderr]).to eq "2"
+    expect(result.to_h[:status]).to eq 1
+  end
+  it "run to_s method" do
+    result = RBatch::cmd "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
+    expect(result.to_s).to eq "{:cmd_str=>\"ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'\", :stdout=>\"1\", :stderr=>\"2\", :status=>1}"
+  end
+  it "raise error when command is nil" do
+    expect {
+      RBatch::Cmd.new(nil)
+    }.to raise_error(RBatch::CmdException)
+  end
+  it "run RBatch::Cmd.new method" do
+    result = RBatch::Cmd.new("ruby -e 'STDOUT.print 1; STDERR.print 2; exit 0;'").run
+    expect(result.stdout.chomp).to eq "1"
+    expect(result.stderr.chomp).to eq "2"
+    expect(result.status).to eq 0
+  end
+
+
+  describe "option by argument" do
+    describe "timeout" do
+      it "run successfuly when command is short time" do
+        opt = {:timeout => 2}
+        expect {
+          RBatch::cmd("ruby -e 'sleep 1'",opt)
+        }.to_not raise_error
+      end
+      it "raise timeout error when command is long time" do
+        opt = {:timeout => 1}
+        expect {
+          RBatch::cmd("ruby -e 'sleep 2'",opt)
+        }.to raise_error(RBatch::CmdException)
+      end
+    end
+  end
+
+  describe "option by argument" do
+    describe "timeout" do
+      it "run successfuly when command is short time" do
+        opt = {:timeout => 2}
+        expect {
+          RBatch::cmd("ruby -e 'sleep 1'",opt)
+        }.to_not raise_error
+      end
+      it "raise timeout error when command is long time" do
+        opt = {:timeout => 1}
+        expect {
+          RBatch::cmd("ruby -e 'sleep 2'",opt)
+        }.to raise_error(RBatch::CmdException)
+      end
+    end
+  end
+
+  describe "option by config" do
+    before :all do
+      @config_dir=File.join(RBatch.home_dir,"conf")
+      @config_file = File.join(@config_dir , "rbatch.yaml")
+      Dir::mkdir @config_dir if ! Dir.exists? @config_dir
+    end
+    describe "raise" do
+      before :all do
+        open( @config_file  , "w" ){|f| f.write("cmd_raise: true")}
+        RBatch.load_rbatch_config
+      end
+      it "raise error when command status is not 0" do
+        expect {
+          RBatch::cmd "ruby -e 'exit 1;'"
+        }.to raise_error(RBatch::CmdException)
+      end
+      after :each do
+        FileUtils.rm @config_file
+      end
+    end
+  end
+end

data/spec/config_test.spec

@@ -0,0 +1,48 @@
+require 'tmpdir'
+ENV["RB_HOME"]=Dir.tmpdir
+
+require 'rbatch'
+
+describe RBatch::Config do
+  before :all do
+    @config_dir=RBatch.config_dir
+    @config_file = File.join(@config_dir , "rspec.yaml")
+    Dir::mkdir @config_dir if ! Dir.exists? @config_dir
+  end
+
+  before :each do
+  end
+
+  after :each do
+    FileUtils.rm @config_file if File.exists? @config_file
+  end
+
+  after :all do
+  end
+
+  it "read config" do
+    open( @config_file  , "w" ){|f| f.write("key: value")}
+    expect(RBatch.config["key"]).to eq "value"
+  end
+
+  it "raise error when config does not exist" do
+    expect {
+      RBatch.config
+    }.to raise_error(Errno::ENOENT)
+  end
+
+  it "read config twice" do
+    open( @config_file  , "w" ){|f| f.write("key: value")}
+    expect(RBatch.config["key"]).to eq "value"
+    expect(RBatch.config["key"]).to eq "value"
+  end
+
+  it "raise error when read value which key does not exist" do
+    open( @config_file  , "w" ){|f| f.write("key: value")}
+    expect {
+      RBatch.config["not_exist"]
+    }.to raise_error(RBatch::Config::Exception)
+  end
+
+
+end

data/spec/log_test.spec

@@ -0,0 +1,430 @@
+require 'tmpdir'
+ENV["RB_HOME"]=Dir.tmpdir
+
+require 'rbatch'
+
+describe RBatch::Log do
+
+  before :all do
+    @dir = RBatch.log_dir
+    Dir::mkdir(@dir)if ! Dir.exists? @dir
+  end
+
+  before :each do
+    # set quiet option
+    confstr = "log_quiet: true\n"
+    open( RBatch.rbatch_config_path  , "w" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
+  end
+
+  after :each do
+    Dir::foreach(@dir) do |f|
+      File::delete(File.join(@dir , f)) if ! (/\.+$/ =~ f)
+    end
+  end
+
+  it "is run" do
+    RBatch::Log.new do | log |
+      log.info("test_log")
+    end
+    Dir::foreach(@dir) do |f|
+      if ! (/\.+$/ =~ f)
+        File::open(File.join(@dir , f)) {|f|
+          expect(f.read).to match /test_log/
+        }
+      end
+    end
+  end
+
+  it "raise error when log dir does not exist" do
+    Dir::rmdir(@dir)
+    expect{
+      RBatch::Log.new {|log|}
+    }.to raise_error(Errno::ENOENT)
+    Dir::mkdir(@dir)
+  end
+
+  it "run when log block is nested" do
+    RBatch::Log.new({:name => "name1" }) do | log |
+      log.info("name1")
+      RBatch::Log.new({:name => "name2" }) do | log |
+        log.info("name2")
+      end
+    end
+    File::open(File.join(@dir,"name1")) {|f| expect(f.read).to match /name1/ }
+    File::open(File.join(@dir,"name2")) {|f| expect(f.read).to match /name2/ }
+  end
+
+  describe "option by argument" do
+    it "change log name" do
+      RBatch::Log.new({:name => "name1.log" }) do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@dir , "name1.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+    it "change log name 2" do
+      RBatch::Log.new({:name => "<prog><date>name.log" }) do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@dir ,  "rspec" + Time.now.strftime("%Y%m%d") + "name.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+   it "change log name 3" do
+      RBatch::Log.new({:name => "<prog>-<date>-name.log" }) do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@dir ,  "rspec-" + Time.now.strftime("%Y%m%d") + "-name.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+    it "change log dir" do
+      @tmp = Dir.tmpdir
+      RBatch::Log.new({:name => "c.log", :dir=> @tmp }) do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@tmp , "c.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+    it "is append mode" do
+      RBatch::Log.new({:append => true, :name =>  "a.log" }) do | log |
+        log.info("line1")
+      end
+      RBatch::Log.new({:append => true, :name =>  "a.log" }) do | log |
+        log.info("line2")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to match /line1/
+        expect(str).to match /line2/
+      }
+    end
+
+    it "is overwrite mode" do
+      RBatch::Log.new({:append => false, :name =>  "a.log" }) do | log |
+        log.info("line1")
+      end
+      RBatch::Log.new({:append => false, :name =>  "a.log" }) do | log |
+        log.info("line2")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /line1/
+        expect(str).to match /line2/
+      }
+    end
+
+    it "is debug level" do
+      RBatch::Log.new({ :level => "debug",:name =>  "a.log" }) do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to match /test_debug/
+        expect(str).to match /test_info/
+        expect(str).to match /test_warn/
+        expect(str).to match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "is info level" do
+      RBatch::Log.new({ :level => "info",:name =>  "a.log" }) do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /test_debug/
+        expect(str).to match /test_info/
+        expect(str).to match /test_warn/
+        expect(str).to match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "is warn level" do
+      RBatch::Log.new({ :level => "warn",:name =>  "a.log" }) do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /test_debug/
+        expect(str).to_not match /test_info/
+        expect(str).to match /test_warn/
+        expect(str).to match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "is error level" do
+      RBatch::Log.new({ :level => "error",:name =>  "a.log" }) do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /test_debug/
+        expect(str).to_not match /test_info/
+        expect(str).to_not match /test_warn/
+        expect(str).to match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "is fatal level" do
+      RBatch::Log.new({ :level => "fatal",:name =>  "a.log" }) do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /test_debug/
+        expect(str).to_not match /test_info/
+        expect(str).to_not match /test_warn/
+        expect(str).to_not match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "is default level" do
+      RBatch::Log.new({ :name =>  "a.log" }) do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /test_debug/
+        expect(str).to match /test_info/
+        expect(str).to match /test_warn/
+        expect(str).to match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "delete old log which name include <date>" do
+      loglist = [*0..20].map do |day|
+        File.join(@dir , (Date.today - day).strftime("%Y%m%d") + "_test_delete.log")
+      end
+      FileUtils.touch(loglist)
+      log = RBatch::Log.new({ :name =>  "<date>_test_delete.log",:delete_old_log => true})
+      log.close
+      loglist[1..6].each do |filename|
+        expect(File.exists?(filename)).to be true
+      end
+      loglist[7..20].each do |filename|
+        expect(File.exists?(filename)).to be false
+      end
+    end
+
+    it "delete old log which name include <date> even if <date> position is changed" do
+      loglist = [*0..20].map do |day|
+        File.join(@dir , "235959-" + (Date.today - day).strftime("%Y%m%d") + "_test_delete.log")
+      end
+      FileUtils.touch(loglist)
+      log = RBatch::Log.new({ :name =>  "<time>-<date>_test_delete.log",:delete_old_log => true})
+      log.close
+      loglist[1..6].each do |filename|
+        expect(File.exists?(filename)).to be true
+      end
+      loglist[7..20].each do |filename|
+        expect(File.exists?(filename)).to be false
+      end
+    end
+
+    it "does not delete old log which name does not include <date>" do
+      log = RBatch::Log.new({ :name =>  "test_delete.log",:delete_old_log => true})
+      log.close
+      expect(File.exists?(File.join(@dir,"test_delete.log"))).to be true
+    end
+
+
+  end
+
+  describe "option by config" do
+    it "change log name" do
+      confstr = "log_name: name1.log"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      RBatch::Log.new() do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@dir , "name1.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+    it "change log dir" do
+      @tmp = Dir.tmpdir
+      confstr = "log_name: c.log\nlog_dir: " + @tmp
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      RBatch::Log.new({:name => "c.log", :dir=> @tmp }) do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@tmp , "c.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+    it "is append mode" do
+      confstr = "log_name: a.log\nappend: true"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      RBatch::Log.new() do | log |
+        log.info("line1")
+      end
+      RBatch::Log.new() do | log |
+        log.info("line2")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to match /line1/
+        expect(str).to match /line2/
+      }
+    end
+
+    it "is overwrite mode" do
+      confstr = "log_name: a.log\nlog_append: false"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      RBatch::Log.new() do | log |
+        log.info("line1")
+      end
+      RBatch::Log.new() do | log |
+        log.info("line2")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /line1/
+        expect(str).to match /line2/
+      }
+    end
+
+    it "is warn level" do
+      confstr = "log_name: a.log\nlog_level: warn"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      RBatch::Log.new() do | log |
+        log.debug("test_debug")
+        log.info("test_info")
+        log.warn("test_warn")
+        log.error("test_error")
+        log.fatal("test_fatal")
+      end
+      File::open(File.join(@dir , "a.log")) {|f|
+        str = f.read
+        expect(str).to_not match /test_debug/
+        expect(str).to_not match /test_info/
+        expect(str).to match /test_warn/
+        expect(str).to match /test_error/
+        expect(str).to match /test_fatal/
+      }
+    end
+
+    it "delete old log file which name include <date>" do
+      confstr = "log_delete_old_log: true"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      loglist = [*0..20].map do |day|
+        File.join(@dir , (Date.today - day).strftime("%Y%m%d") + "_test_delete.log")
+      end
+      FileUtils.touch(loglist)
+      log = RBatch::Log.new({ :name =>  "<date>_test_delete.log"})
+      log.close
+      loglist[1..6].each do |filename|
+        expect( File.exists?(filename)).to be true
+      end
+      loglist[7..20].each do |filename|
+        expect( File.exists?(filename)).to be false
+      end
+    end
+  end
+
+  describe "option by both argument and config" do
+    it "is prior to argument than config" do
+      confstr = "log_name: a.log"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      RBatch::Log.new({:name => "b.log"}) do | log |
+        log.info("hoge")
+      end
+      File::open(File.join(@dir , "b.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+  end
+
+  describe "instance" do
+    it "run" do
+      log = RBatch::Log.new
+      expect(log).to_not be_nil
+      log.info("test_log")
+      log.close
+      Dir::foreach(@dir) do |f|
+        if ! (/\.+$/ =~ f)
+          File::open(File.join(@dir , f)) {|f|
+            expect(f.read).to match /test_log/
+          }
+        end
+      end
+    end
+
+    it "raise error when log dir does not exist" do
+      Dir::rmdir(@dir)
+      expect{
+        RBatch::Log.new
+      }.to raise_error(Errno::ENOENT)
+      Dir::mkdir(@dir)
+    end
+
+    it "option by argument" do
+      log = RBatch::Log.new({:name => "d.log" })
+      log.info("hoge")
+      log.close
+      File::open(File.join(@dir , "d.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+
+
+    it "option by config" do
+      confstr = "log_name: e.log"
+      open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+      RBatch.load_rbatch_config
+      log = RBatch::Log.new()
+      log.info("hoge")
+      log.close
+      File::open(File.join(@dir , "e.log")) {|f|
+        expect(f.read).to match /hoge/
+      }
+    end
+  end
+end

data/spec/rbatch_test.spec

@@ -0,0 +1,25 @@
+require 'rbatch'
+
+describe RBatch do
+  before :all do
+    RBatch.home_dir=Dir.tmpdir
+    @config_dir=File.join(RBatch.home_dir,"conf")
+    @config_file = File.join(@config_dir , "rbatch.yaml")
+    Dir::mkdir @config_dir if ! Dir.exists? @config_dir
+  end
+
+  before :each do
+  end
+
+  it "makes lock file when forbid_double_run is enable" do
+    open( @config_file  , "w" ){|f| f.write("forbid_double_run: true")}
+  end
+
+  after :each do
+    FileUtils.rm @config_file if File.exists? @config_file
+  end
+
+  after :all do
+  end
+
+end

data/test/cases/test_cmd.rb

@@ -7,6 +7,7 @@ class RuncherTest < Test::Unit::TestCase
     Dir::mkdir(@config_dir) if ! Dir.exists? @config_dir
     confstr = ""
     open( RBatch.rbatch_config_path  , "w" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
   end
 
   def test_cmd_exists
@@ -105,6 +106,7 @@ class RuncherTest < Test::Unit::TestCase
   def test_opt_raise_true_status_1_by_conf
     confstr = "cmd_raise: true "
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     cmd_str = "ruby -e 'STDOUT.print 1; STDERR.print 2; exit 1;'"
     assert_raise(RBatch::CmdException){
       RBatch::Cmd.new(cmd_str).run

data/test/cases/test_log.rb

@@ -14,7 +14,7 @@ class LoggerTest < Test::Unit::TestCase
     # set STDOUT Logger stop
     confstr = "log_quiet: true\n"
     open( RBatch.rbatch_config_path  , "w" ){|f| f.write(confstr)}
-
+    RBatch.load_rbatch_config
   end
 
   def teardown
@@ -85,6 +85,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_change_name_by_config
     confstr = "log_name: name1"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({:name => "name1.log" }) do | log |
       log.info("test_change_name_by_config")
     end
@@ -110,6 +111,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_change_log_dir_by_config
     confstr = "log_dir: " + @dir2
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({:output_dir=> @dir2 }) do | log |
       log.info("test_change_log_dir_by_config")
     end
@@ -136,6 +138,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_opt_overwite_config
     confstr = "log_name: " + "name1"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({:name => "name2" }) do | log |
       log.info("test_opt_overwite_config")
     end
@@ -176,6 +179,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_append_by_conf
     confstr = "log_append: true"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
 
     RBatch::Log.new({:name =>  "test_append" }) do | log |
       log.info("test_append1")
@@ -193,6 +197,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_no_append_by_conf
     confstr = "log_append: false"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
 
     RBatch::Log.new({ :name =>  "test_append" }) do | log |
       log.info("test_append1")
@@ -319,6 +324,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_log_level_debug_by_conf
     confstr = "log_level: debug"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
 
     RBatch::Log.new({ :name =>  "test_level" }) do | log |
       log.debug("test_debug")
@@ -340,6 +346,7 @@ class LoggerTest < Test::Unit::TestCase
  def test_log_level_info_by_conf
     confstr = "log_level: info"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({ :name =>  "test_level" }) do | log |
       log.debug("test_debug")
       log.info("test_info")
@@ -360,6 +367,7 @@ class LoggerTest < Test::Unit::TestCase
  def test_log_level_warn_by_conf
     confstr = "log_level: warn"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({ :name =>  "test_level" }) do | log |
       log.debug("test_debug")
       log.info("test_info")
@@ -380,6 +388,7 @@ class LoggerTest < Test::Unit::TestCase
  def test_log_level_error_by_conf
     confstr = "log_level: error"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({ :name =>  "test_level" }) do | log |
       log.debug("test_debug")
       log.info("test_info")
@@ -400,6 +409,7 @@ class LoggerTest < Test::Unit::TestCase
  def test_log_level_fatal_by_conf
     confstr = "log_level: fatal"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
     RBatch::Log.new({ :name =>  "test_level" }) do | log |
       log.debug("test_debug")
       log.info("test_info")
@@ -510,6 +520,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_i_log_level_debug_by_conf
     confstr = "log_level: debug"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
 
     log = RBatch::Log.new({ :name =>  "test_level" })
     log.debug("test_debug")
@@ -545,6 +556,7 @@ class LoggerTest < Test::Unit::TestCase
   def test_delete_old_log_by_config
     confstr = "log_delete_old_log: true"
     open( RBatch.rbatch_config_path  , "a" ){|f| f.write(confstr)}
+    RBatch.load_rbatch_config
 
     loglist = [*0..20].map do |day|
       File.join(@dir , (Date.today - day).strftime("%Y%m%d") + "_test_delete.log")

metadata

@@ -2,7 +2,7 @@
 name: rbatch
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.13.0
+  version: 1.13.1
 platform: ruby
 authors: 
 - fetaro
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-12-18 00:00:00 Z
+date: 2013-12-20 00:00:00 Z
 dependencies: []
 
 description: RBatch has many fanctions to help with your making a batch script such as "data backup script" or "proccess starting script".
@@ -105,6 +105,10 @@ files:
 - sample/data/amAuthentication.error.1
 - sample/data/amAuthentication.error.2012-07-10
 - sample/log/empty
+- spec/cmd_test.spec
+- spec/config_test.spec
+- spec/log_test.spec
+- spec/rbatch_test.spec
 - test/cases/test_cmd.rb
 - test/cases/test_common_config.rb
 - test/cases/test_config.rb
@@ -139,6 +143,10 @@ signing_key:
 specification_version: 3
 summary: Ruby-based simple batch framework
 test_files: 
+- spec/cmd_test.spec
+- spec/config_test.spec
+- spec/log_test.spec
+- spec/rbatch_test.spec
 - test/cases/test_cmd.rb
 - test/cases/test_common_config.rb
 - test/cases/test_config.rb