scout-essentials 1.0.0

data/test/scout/simple_opt/test_setup.rb

@@ -0,0 +1,77 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require 'scout/simple_opt'
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestSOPTSetup < Test::Unit::TestCase
+  def setup
+    SOPT.inputs = nil
+    SOPT.input_types = nil
+    SOPT.input_descriptions = nil
+    SOPT.input_shortcuts = nil
+  end
+
+  def test_setup
+    SOPT.setup <<-EOF
+Test application
+
+$ test cmd -arg 1
+
+It does some imaginary stuff
+
+-a--arg* Argument
+-a2--arg2* Argument
+
+    EOF
+
+    assert_equal "test cmd -arg 1", SOPT.synopsys
+    assert SOPT.inputs.include? "arg"
+    assert SOPT.inputs.include? "arg2"
+  end
+
+  def test_setup_alt
+    SOPT.setup <<-EOF
+Test application
+
+It does some imaginary stuff
+
+-a--arg* Argument
+-a2--arg2* Argument
+
+    EOF
+
+    assert SOPT.inputs.include? "arg"
+    assert SOPT.inputs.include? "arg2"
+  end
+
+  def test_setup_alt2
+    SOPT.setup <<-EOF
+Test application
+
+-a--arg* Argument
+-a2--arg2* Argument
+
+    EOF
+
+    assert SOPT.inputs.include? "arg"
+    assert SOPT.inputs.include? "arg2"
+  end
+
+  def test_setup_alt3
+    SOPT.setup <<-EOF
+Pulls the values from a tsv colum
+
+$ rbbt tsv values [options] <filename.tsv|->
+
+Use - to read from STDIN
+
+-tch--tokyocabinet File is a tokyocabinet hash database
+-tcb--tokyocabinet_bd File is a tokyocabinet B database
+-h--help Print this help
+    EOF
+
+    assert SOPT.inputs.include? "tokyocabinet"
+  end
+
+end
+
+

data/test/scout/test_cmd.rb

@@ -0,0 +1,85 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/open'
+
+class TestCmd < Test::Unit::TestCase
+
+  def test_cmd_option_string
+    assert_equal("--user-agent 'firefox'", CMD.process_cmd_options("--user-agent" => "firefox"))
+    assert_equal("--user-agent='firefox'", CMD.process_cmd_options("--user-agent=" => "firefox"))
+    assert_equal("-q", CMD.process_cmd_options("-q" => true))
+    assert_equal("", CMD.process_cmd_options("-q" => nil))
+    assert_equal("", CMD.process_cmd_options("-q" => false))
+
+    assert(CMD.process_cmd_options("--user-agent" => "firefox", "-q" => true) =~ /--user-agent 'firefox'/)
+    assert(CMD.process_cmd_options("--user-agent" => "firefox", "-q" => true) =~ /-q/)
+  end
+
+  def test_cmd
+    assert_equal("test\n", CMD.cmd("echo '{opt}' test").read)
+    assert_equal("test", CMD.cmd("echo '{opt}' test", "-n" => true).read)
+    assert_equal("test2\n", CMD.cmd("cut", "-f" => 2, "-d" => ' ', :in => "test1 test2").read)
+  end
+
+  def test_pipe
+    assert_equal("test\n", CMD.cmd("echo test", :pipe => true).read)
+    assert_equal("test\n", CMD.cmd("echo '{opt}' test", :pipe => true).read)
+    assert_equal("test", CMD.cmd("echo '{opt}' test", "-n" => true, :pipe => true).read)
+    assert_equal("test2\n", CMD.cmd("cut", "-f" => 2, "-d" => ' ', :in => "test1 test2", :pipe => true).read)
+  end
+
+  def test_error
+    Log.with_severity 6 do
+      assert_raise ProcessFailed do CMD.cmd('fake-command') end
+      assert_raise ProcessFailed do CMD.cmd('ls -fake_option') end
+
+      assert_raise ProcessFailed do CMD.cmd('fake-command', :stderr => true) end
+      assert_raise ProcessFailed do CMD.cmd('ls -fake_option', :stderr => true) end
+
+      assert_nothing_raised ProcessFailed do CMD.cmd('fake-command', :no_fail => true, :pipe => true) end
+      assert_nothing_raised ProcessFailed do CMD.cmd('ls -fake_option', :no_fail => true, :pipe => true) end
+
+      assert_raise ProcessFailed do CMD.cmd('fake-command', :stderr => true, :pipe => true).join end
+      assert_raise ConcurrentStreamProcessFailed do CMD.cmd('ls -fake_option', :stderr => true, :pipe => true).join end
+    end
+  end
+
+  def test_pipes
+    text = <<-EOF
+line1
+line2
+line3
+line11
+line22
+line33
+    EOF
+
+    TmpFile.with_file(text * 100) do |file|
+
+      Open.open(file) do |f|
+        io = CMD.cmd('tail -n 10', :in => f, :pipe => true)
+        io2 = CMD.cmd('head -n 10', :in => io, :pipe => true)
+        io3 = CMD.cmd('head -n 10', :in => io2, :pipe => true)
+        assert_equal 10, io3.read.split(/\n/).length
+      end
+    end
+  end
+
+  def test_STDIN_close
+    TmpFile.with_file("Hello") do |file|
+      STDIN.close
+      Open.open(file) do |f|
+        io = CMD.cmd("tr 'e' 'E'", :in => f, :pipe => true)
+        txt = io.read
+        io.join
+        assert_equal "HEllo", txt
+      end
+    end
+  end
+
+  def test_bash
+    assert_equal "TEST", CMD.bash("echo TEST").read.strip
+    assert_equal ENV["HOME"], CMD.bash("echo $HOME").read.strip
+  end
+end

data/test/scout/test_concurrent_stream.rb

@@ -0,0 +1,29 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+require 'scout/exceptions'
+require 'scout/cmd'
+
+class TestClass < Test::Unit::TestCase
+  def test_concurrent_stream_pipe
+    io = CMD.cmd("ls", :pipe => true, :autojoin => true)
+    io.read
+    io.close 
+  end
+
+  def test_concurrent_stream_process_failed
+    assert_raise ConcurrentStreamProcessFailed do 
+      io = CMD.cmd("grep . NONEXISTINGFILE", :pipe => true, :autojoin => true)
+      io.read
+      io.close 
+    end
+  end
+
+  def test_concurrent_stream_process_failed_autojoin
+    assert_raise ConcurrentStreamProcessFailed do 
+      io = CMD.cmd("grep . NONEXISTINGFILE", :pipe => true, :autojoin => true) 
+      io.read
+    end
+  end
+end
+

data/test/scout/test_config.rb

@@ -0,0 +1,66 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestConfig < Test::Unit::TestCase
+  setup do
+    Scout::Config.set({:cpus => 30}, :test_config, :test)
+    Scout::Config.set(:cpus, 5, "slow::2", :test)
+    Scout::Config.set({:token => "token"}, "token")
+    Scout::Config.set(:notoken, "no_token")
+    Scout::Config.set({:emptytoken => "empty"})
+  end
+
+  def test_simple
+    assert_equal 30, Scout::Config.get(:cpus, :test_config)
+  end
+
+  def test_match
+    assert_equal({20 => ["token"]}, Scout::Config.match({["key:token"] => "token"}, "key:token"))
+  end
+
+  def test_simple_no_token
+    assert_equal "token", Scout::Config.get("token", "token")
+    assert_equal "no_token", Scout::Config.get("notoken", "key:notoken")
+    assert_equal 'token', Scout::Config.get("token", "key:token")
+    assert_equal 'token', Scout::Config.get("token")
+    assert_equal nil, Scout::Config.get("token", "someotherthing")
+    assert_equal "default_token", Scout::Config.get("token", 'unknown', :default => 'default_token')
+    assert_equal 'empty', Scout::Config.get("emptytoken", 'key:emptytoken')
+  end
+
+  def test_prio
+    assert_equal 5, Scout::Config.get(:cpus, :slow, :test)
+  end
+
+  def test_with_config
+    Scout::Config.add_entry 'key', 'valueA', 'token'
+    assert_equal "valueA", Scout::Config.get('key', 'token')
+    assert_equal "default", Scout::Config.get('key2', 'token', :default => 'default')
+
+    Scout::Config.with_config do 
+      Scout::Config.add_entry 'key', 'valueB', 'token'
+      Scout::Config.add_entry 'key2', 'valueB2', 'token'
+      assert_equal "valueB", Scout::Config.get('key', 'token')
+      assert_equal "valueB2", Scout::Config.get('key2', 'token', :default => 'default')
+    end
+
+    assert_equal "valueA", Scout::Config.get('key', 'token')
+    assert_equal "default", Scout::Config.get('key2', 'token', :default => 'default')
+  end
+
+  def test_order
+    Scout::Config.add_entry 'key', 'V1', 'token1'
+    Scout::Config.add_entry 'key', 'V2', 'token2'
+    Scout::Config.add_entry 'key', 'V3', 'token2'
+
+    assert_equal "V3", Scout::Config.get('key', 'token2')
+    assert_equal "V1", Scout::Config.get('key', 'token1')
+    assert_equal "V3", Scout::Config.get('key', 'token2', 'token1')
+    assert_equal "V1", Scout::Config.get('key', 'token1', 'token2')
+  end
+
+  def test_default
+    Scout::Config.add_entry 'key', 'V1', 'token1'
+    assert_equal "V3", Scout::Config.get('key', 'token2', :default => 'V3')
+  end
+end

data/test/scout/test_indiferent_hash.rb

@@ -0,0 +1,26 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestClass < Test::Unit::TestCase
+  def test_indiferent_hash
+    a = {:a => 1, "b" => 2}
+    a.extend IndiferentHash
+
+    assert_equal 1, a[:a]
+    assert_equal 1, a["a"]
+    assert_equal 2, a["b"]
+    assert_equal 2, a[:b]
+  end
+
+  def test_case_insensitive_hash
+    a = {:a => 1, "b" => 2}
+    a.extend CaseInsensitiveHash
+
+    assert_equal 1, a[:a]
+    assert_equal 1, a["A"]
+    assert_equal 1, a[:A]
+    assert_equal 2, a["B"]
+    assert_equal 2, a[:b]
+  end
+end
+

data/test/scout/test_log.rb

@@ -0,0 +1,32 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestLog < Test::Unit::TestCase
+  def test_get_level
+    assert_equal 0, Log.get_level(:debug)
+    assert_equal 1, Log.get_level(:low)
+    assert_equal 1, Log.get_level("LOW")
+    assert_equal 1, Log.get_level(1)
+    assert_equal 0, Log.get_level(nil)
+  end
+
+  def test_color
+    assert Log.color(:green, "green")
+  end
+
+  def test_iif
+    TmpFile.with_file do |tmp|
+      Log.logfile(tmp)
+      iif :foo
+      assert File.read(tmp).include? ":foo"
+      assert File.read(tmp).include? "INFO"
+    end
+  end
+
+  def test_tty_size
+    assert Integer === Log.tty_size
+  end
+
+end
+
+

data/test/scout/test_meta_extension.rb

@@ -0,0 +1,80 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestMetaExtension < Test::Unit::TestCase
+  module ExtensionClass
+    extend MetaExtension
+
+    extension_attr :code, :code2
+  end
+
+  module ExtensionClass2
+    extend MetaExtension
+
+    extension_attr :code3, :code4
+  end
+
+
+  def test_setup_annotate
+    str = "String"
+    ExtensionClass.setup(str, :code)
+    assert ExtensionClass === str
+    assert_equal :code, str.code
+
+    str2 = "String2"
+    str.annotate(str2)
+    assert_equal :code, str2.code
+  end
+
+  def test_marshal
+    str = "String"
+    ExtensionClass.setup(str, :code)
+    assert ExtensionClass === str
+    assert_equal :code, str.code
+
+    str2 = Marshal.load(Marshal.dump(str))
+    assert_equal :code, str2.code
+  end
+
+  def test_setup_alternatives
+    str = "String"
+
+    ExtensionClass.setup(str, :code2 => :code)
+    assert_equal :code, str.code2
+
+    ExtensionClass.setup(str, code2: :code)
+    assert_equal :code, str.code2
+
+    ExtensionClass.setup(str, "code2" => :code)
+    assert_equal :code, str.code2
+
+  end
+
+  def test_setup_block
+    o = ExtensionClass.setup nil, :code => :c, :code2 => :c2 do
+      puts 1
+    end
+
+    assert o.extension_attr_hash.include?(:code)
+    assert o.extension_attr_hash.include?(:code2)
+  end
+
+  def test_twice
+    str = "String"
+
+    ExtensionClass.setup(str, :code2 => :code)
+    assert_equal :code, str.code2
+    assert_include str.instance_variable_get(:@extension_attrs), :code
+
+    str.extend ExtensionClass2
+    str.code3 = :code_alt
+    assert_equal :code, str.code2
+    assert_equal :code_alt, str.code3
+    assert_include str.instance_variable_get(:@extension_attrs), :code
+    assert_include str.instance_variable_get(:@extension_attrs), :code3
+
+    assert_include str.extension_attr_hash, :code
+    assert_include str.extension_attr_hash, :code3
+  end
+end
+

data/test/scout/test_misc.rb

@@ -0,0 +1,6 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestMisc < Test::Unit::TestCase
+end
+

data/test/scout/test_named_array.rb

@@ -0,0 +1,43 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestNamedArray < Test::Unit::TestCase
+  def test_identify_names
+    names =<<-EOF.split("\n")
+ValueA
+ValueB (Entity type)
+15
+    EOF
+    assert_equal 0, NamedArray.identify_name(names, "ValueA")
+    assert_equal :key, NamedArray.identify_name(names, :key)
+    assert_equal 0, NamedArray.identify_name(names, nil)
+    assert_equal 1, NamedArray.identify_name(names, "ValueB (Entity type)")
+    assert_equal 1, NamedArray.identify_name(names, "ValueB")
+    assert_equal 1, NamedArray.identify_name(names, 1)
+  end
+
+  def test_missing_field
+    a = NamedArray.setup([1,2], [:a, :b])
+    assert_equal 1, a[:a]
+    assert_equal nil, a[:c]
+  end
+
+  def test_zip_fields
+    a = [%w(a b), %w(1 1)]
+    assert_equal [%w(a 1), %w(b 1)], NamedArray.zip_fields(a)
+  end
+
+  def test_add_zipped
+    a = [%w(a b), %w(1 1)]
+    NamedArray.add_zipped a, [%w(c), %w(1)]
+    NamedArray.add_zipped a, [%w(d), %w(1)]
+    assert_equal [%w(a b c d), %w(1 1 1 1)], a
+  end
+
+  def test_method_missing
+    a = NamedArray.setup([1,2], [:a, :b])
+    assert_equal 1, a.a
+    assert_equal 2, a.b
+  end
+end
+

data/test/scout/test_open.rb

@@ -0,0 +1,146 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestOpen < Test::Unit::TestCase
+
+  def test_read
+    content =<<-EOF
+1
+2
+3
+4
+    EOF
+    TmpFile.with_file(content) do |file|
+      sum = 0
+      Open.read file do |line| sum += line.to_i end
+      assert_equal(1 + 2 + 3 + 4, sum)
+      assert_equal(content, Open.read(file))
+    end
+  end
+
+  def test_gzip
+    content =<<-EOF
+1
+2
+3
+4
+    EOF
+    TmpFile.with_file(content) do |file|
+      `gzip #{file}`
+      assert_equal(content, Open.read(file + '.gz'))
+      FileUtils.rm file + '.gz'
+    end
+  end
+
+
+
+  #def test_wget
+  #  assert(Misc.fixutf8(Open.wget('http://google.com', :quiet => true).read) =~ /html/)
+  #end
+
+  #def test_nice
+  #  nice =  0.5
+
+  #  t = Time.now
+  #  Open.wget('http://google.com', :quiet => true, :nice => nice).read
+  #  assert(Time.now - t + 0.5 >= nice)
+
+  #  Open.wget('http://google.com', :quiet => true, :nice => nice, :nice_key => 1).read
+  #  t = Time.now
+  #  Open.wget('http://google.com', :quiet => true, :nice => nice, :nice_key => 1).read
+  #  assert(Time.now - t + 0.5 >= nice)
+  #end
+
+  #def test_remote?
+  #  assert(Open.remote?('http://google.com'))
+  #  assert(! Open.remote?('~/.bashrc'))
+  #end
+
+  #def test_open
+  #  assert(Open.read('http://google.com', :quiet => true, :nocache => :update) =~ /html/)
+  #end
+
+  #def test_repo_dir
+  #  file1 = "TEST"
+  #  file2 = "TEST" * 1000
+  #  TmpFile.with_file do |tmpdir|
+  #    tmpdir = Rbbt.tmp.repo_dir.find
+  #    normal = File.join(tmpdir, 'normal')
+  #    repo = File.join(tmpdir, 'repo')
+
+  #    Open.repository_dirs.push(repo)
+
+  #    Misc.benchmark(100) do
+  #      filename = "file" << (rand * 100).to_i.to_s
+  #      Open.write(File.join(normal, filename), file2)
+  #      100.times do 
+  #        Open.read(File.join(normal,  filename))
+  #      end
+  #    end
+
+  #    Misc.benchmark(100) do
+  #      filename = "file" << (rand * 100).to_i.to_s
+  #      Open.write(File.join(repo, filename), file2)
+  #      100.times do 
+  #        Open.read(File.join(repo, filename))
+  #      end
+  #    end
+  #  end
+  #end
+  #
+  #def test_repo_dir2
+  #  TmpFile.with_file do |tmpdir|
+  #    tmpdir = Rbbt.tmp.repo_dir.find
+  #    repo = File.join(tmpdir, 'repo')
+
+  #    Open.repository_dirs.push(repo)
+
+  #    obj = { :a => "???a"}
+  #    filename = "file" << (rand * 100).to_i.to_s
+  #    Open.write(File.join(repo, filename), Marshal.dump(obj))
+  #    dump = Open.read(File.join(repo, filename))
+  #    obj_cp = Marshal.load(dump)
+  #    assert_equal obj, obj_cp
+  #  end
+  #end
+
+  #def test_repo_marshal
+  #  TmpFile.with_file do |tmpdir|
+  #    tmpdir = Rbbt.tmp.repo_dir.find
+  #    repo = File.join(tmpdir, 'repo')
+
+  #    filename = 'file'
+  #    Open.repository_dirs.push(repo)
+
+  #    obj = {:a => "string", :pid => nil, :num => 1000, :p  => Rbbt.tmp.foo}
+  #    Open.write(File.join(repo, filename), Marshal.dump(obj))
+  #    new =Open.open(File.join(repo, filename)) do |f|
+  #      Marshal.load(f)
+  #    end
+
+  #    assert_equal new, obj
+  #  end
+
+  #end
+
+  #def test_write_stream_repo
+  #  TmpFile.with_file do |tmpdir|
+  #    tmpdir = Rbbt.tmp.repo_dir.find
+  #    repo = File.join(tmpdir, 'repo')
+
+  #    file = File.join(repo, 'file')
+  #    Open.repository_dirs.push(repo)
+
+  #    text = (["text"] * 5) * "\n"
+
+  #    Misc.consume_stream(StringIO.new(text), false, file)
+
+  #    assert_equal text, Open.read(file)
+  #    assert !File.exist?(file)
+  #    assert Open.exists? file
+  #  end
+
+  #end
+
+end
+

data/test/scout/test_path.rb

@@ -0,0 +1,54 @@
+require File.expand_path(__FILE__).sub(%r(/test/.*), '/test/test_helper.rb')
+require File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+
+class TestPath < Test::Unit::TestCase
+  def test_join
+    path = '/tmp'
+    path.extend Path
+    assert_equal '/tmp/foo', path.join(:foo)
+    assert_equal '/tmp/foo/bar', path.join(:bar, :foo)
+  end
+
+  def test_get
+    path = '/tmp'
+    path.extend Path
+    assert_equal '/tmp/foo', path[:foo]
+    assert_equal '/tmp/foo/bar', path.foo[:bar]
+    assert_equal '/tmp/foo/bar', path[:bar, :foo]
+  end
+
+  def test_slash
+    path = '/tmp'
+    path.extend Path
+    assert_equal '/tmp/foo', path/:foo
+    assert_equal '/tmp/foo/bar', path/:foo/:bar
+    assert_equal '/tmp/foo/bar', path.foo/:bar
+    assert_equal '/tmp/foo/bar', path./(:bar, :foo)
+  end
+
+  def test_setup
+    path = 'tmp'
+    Path.setup(path)
+    assert_equal 'scout', path.pkgdir
+    assert path.libdir.end_with?("scout-essentials")
+  end
+
+  def test_lib_dir
+    TmpFile.with_file do |tmpdir|
+      Path.setup tmpdir
+      FileUtils.mkdir_p tmpdir.lib
+      lib_path = File.expand_path(__FILE__).sub(%r(.*/test/), '').sub(/test_(.*)\.rb/,'\1')
+      lib_path = File.join(Path.caller_lib_dir, 'lib', lib_path)
+      File.write tmpdir.lib.file, <<-EOR 
+require '#{lib_path}'
+a = "1"
+Path.setup(a)
+print a.libdir
+      EOR
+      Misc.in_dir tmpdir.tmp do
+        assert_equal tmpdir, `ruby #{tmpdir.lib.file}`
+      end
+    end
+  end
+end
+