# -*- encoding: binary -*-
require "./test/fresh"
begin
  require 'mogstored_rack'
  require 'unicorn'
  ok = true
rescue LoadError
  ok = false
end

class TestMogstoredRack < Test::Unit::TestCase
  include TestFreshSetup
  def setup
    setup_mogilefs
  end

  def test_range_put_new_file
    add_host_device_domain
    client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain

    io = client.new_file "range0", :largefile => :content_range
    assert_nil io.close
    assert_equal "", client.get_file_data("range0")

    io = client.new_file "writes", :largefile => :content_range
    %w(a b c d e).each { |x| io.write(x) }
    assert_nil io.close
    assert_equal "abcde", client.get_file_data("writes")

    io = client.new_file "puts", :largefile => :content_range
    %w(a b c d e).each { |x| io.puts(x) }
    assert ! client.exist?("puts")
    assert_nil io.close
    assert_equal "a\nb\nc\nd\ne\n", client.get_file_data("puts")
  end

  def test_stream_new_file
    add_host_device_domain
    client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
    client.new_file("chunky", :largefile => :stream) do |io|
      assert_instance_of MogileFS::NewFile::Stream, io
      assert_equal(5, io.write("HELLO"))
      assert_nil io.md5
    end
    assert_equal "HELLO", client.get_file_data("chunky")

    io = client.new_file("puts", :largefile => :stream)
    assert_instance_of MogileFS::NewFile::Stream, io
    assert_equal io, IO.select(nil, [io])[1][0], "IO.select-able"

    assert_nil(io.puts("PUTS!"))
    assert_nil(io.puts("PUTZ"))
    assert_nil io.close
    assert_equal "PUTS!\nPUTZ\n", client.get_file_data("puts")

    io = client.new_file("putc", :largefile => :stream)
    assert_equal(0x20, io.putc(0x20))
    assert_nil io.close
    assert_equal " ", client.get_file_data("putc")

    io = client.new_file("print splat", :largefile => :stream)
    io.print(1, 2, 3)
    assert_nil io.close
    assert_equal "123", client.get_file_data("print splat")

    io = client.new_file("printf", :largefile => :stream)
    assert_nil io.printf("%x", 1638)
    assert_nil io.close
    assert_equal "666", client.get_file_data("printf")

    io = client.new_file("syswrite", :largefile => :stream)
    assert_equal 4, io.syswrite("good")
    assert_equal 7, io.syswrite("morning")
    assert_nil io.close
    assert_equal "goodmorning", client.get_file_data("syswrite")

    io = client.new_file("md5", :largefile=>:stream, :content_md5=>:trailer)
    assert_instance_of Digest::MD5, io.md5
    assert_nil io.puts("HIHI")
    assert_nil io.close
    assert_equal "HIHI\n", client.get_file_data("md5")
    assert_equal Digest::MD5.hexdigest("HIHI\n"), io.md5.hexdigest

    io = client.new_file("<<", :largefile=>:stream)
    assert_equal(io, io << ">>")
    assert_nil io.close
    assert_equal ">>", client.get_file_data("<<")
  end

  def test_stream_new_file_with_content_length
    add_host_device_domain
    client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
    io = client.new_file("clen", :largefile=>:stream,:content_length=>6)
    io << "HIHIHI"
    assert_nil io.close
    assert_equal "HIHIHI", client.get_file_data("clen")

    io = client.new_file("clen", :largefile=>:stream,:content_length=>1)
    io << "FAIL"
    assert_raises(MogileFS::SizeMismatchError) { io.close }
    assert_equal "HIHIHI", client.get_file_data("clen")

    io = client.new_file("md5", :largefile=>:stream,
                                :content_length=>6, :content_md5=>:trailer)
    assert_equal(io, io << "MD5MD5")
    assert_nil io.close
    assert_equal "MD5MD5", client.get_file_data("md5")
    assert_equal Digest::MD5.hexdigest("MD5MD5"), io.md5.hexdigest

    io = client.new_file("md5", :largefile=>:stream,
                                :content_length=>6, :content_md5=>:trailer)
    assert_equal(io, io << "MD5MD")
    assert_raises(MogileFS::SizeMismatchError) { io.close }
    assert_equal Digest::MD5.hexdigest("MD5MD"), io.md5.hexdigest
  end

  def test_md5_check
    add_host_device_domain
    client = MogileFS::MogileFS.new :hosts => @hosts, :domain => @domain
    node = "#@test_host:#@mogstored_http_port"
    pid = fork do
      # not modifying this hash in the same process
      MogileFS::HTTPFile::MD5_TRAILER_NODES[node] = true
      client.store_content("md5_me", nil, "HELLO WORLD")
    end
    _, status = Process.waitpid2(pid)
    assert status.success?, status.inspect
    assert_equal "HELLO WORLD", client.get_file_data("md5_me")
  end

  def setup_mogstored
    @docroot = Dir.mktmpdir(["mogfresh", "docroot"])
    Dir.mkdir("#@docroot/dev1")
    Dir.mkdir("#@docroot/dev2")
    @mogstored_mgmt = TCPServer.new(@test_host, 0)
    @mogstored_http = TCPServer.new(@test_host, 0)
    @mogstored_mgmt_port = @mogstored_mgmt.addr[1]
    @mogstored_http_port = @mogstored_http.addr[1]
    @mogstored_conf = Tempfile.new(["mogstored", "conf"])
    @mogstored_pid = Tempfile.new(["mogstored", "pid"])
    @mogstored_conf.write <<EOF
pidfile = #{@mogstored_pid.path}
maxconns = 1000
mgmtlisten = #@test_host:#{@mogstored_mgmt_port}
server = none
docroot = #@docroot
EOF
    @mogstored_conf.flush
    @mogstored_mgmt.close

    unicorn_setup

    x!("mogstored", "--daemon", "--config=#{@mogstored_conf.path}")
    wait_for_port @mogstored_mgmt_port
  end

  # I would use Rainbows! + *Threads + Ruby 1.9.3 in production
  def unicorn_setup
    @ru = Tempfile.new(%w(mogstored_rack .ru))
    @ru.write <<EOF
run MogstoredRack.new("#@docroot")
EOF
    @ru.flush

    @unicorn_pid = Tempfile.new(%w(unicorn .pid))
    @unicorn_conf = Tempfile.new(%w(unicorn.conf .rb))
    @unicorn_stderr = Tempfile.new(%w(unicorn .stderr))
    @unicorn_stdout = Tempfile.new(%w(unicorn .stdout))
    @unicorn_conf.write <<EOF
require "mogstored_rack"
listen "#@test_host:#{@mogstored_http_port}"
pid "#{@unicorn_pid.path}"
stderr_path "#{@unicorn_stderr.path}"
stdout_path "#{@unicorn_stdout.path}"
rewindable_input false
EOF
    @unicorn_conf.flush

    @mogstored_http.close
    x!("unicorn", "-E", "deployment",
       "--daemon", "--config", @unicorn_conf.path, @ru.path)
    wait_for_port @mogstored_http_port
    40.times do
      break if File.size(@unicorn_pid.path) > 0
      sleep 0.1
    end
  end

  def teardown
    pid = File.read(@unicorn_pid.path).to_i
    Process.kill(:QUIT, pid) if pid > 0
    teardown_mogilefs
    puts(@unicorn_stderr.read) if $DEBUG
  end
end if ok && `which unicorn`.chomp.size > 0