object-stream 0.1

data/test/test-basic.rb

@@ -0,0 +1,176 @@
+require 'object-stream'
+require 'stringio'
+
+require 'minitest/autorun'
+
+module TestBasic
+  attr_reader :sio, :stream
+  
+  # supported by all types
+  BASIC_OBJECTS = [
+    nil,
+    true,
+    false,
+    "The quick brown fox jumped over the lazy dog's back.",
+    [-5, "foo", [4]],
+    {"a" => 1, "b" => 2}
+  ]
+
+  ADVANCED_OBJECTS = [
+    12,
+    2**40 + 123,
+    3.45,
+    { 1 => 2 },
+    { ["a"] => 3 },
+    { {"b" => 5} => 6 }
+  ]
+  
+  class Custom
+    attr_reader :x, :y
+    def initialize x, y
+      @x, @y = x, y
+    end
+    def ==(other)
+      @x == other.x
+      @y == other.y # just enough to make test pass
+    end
+  end
+  
+  RUBY_OBJECTS = [
+    :foo,
+    {:foo => :bar},
+    String,
+    File,
+    Custom.new(1,2)
+  ]
+  
+  def type; self.class::TYPE; end
+  def objects; BASIC_OBJECTS + self.class::OBJECTS; end
+  
+  def setup
+    @sio = StringIO.new
+    @stream = ObjectStream.new sio, type: type
+  end
+  
+  def test_write_read
+    objects.each do |obj|
+      sio.rewind # do not need to clear stream's buffer (if any)
+      sio.truncate 0
+      stream.write obj
+
+      sio.rewind
+      dump = sio.read
+      sio.rewind
+
+      stream.read do |obj2|
+        assert_equal(obj, obj2, "dump is #{dump.inspect}")
+      end
+    end
+  end
+  
+  def test_batch_write
+    a = ["a", "b", "c"]
+    stream.write *a
+    sio.rewind
+    dump = sio.read
+    sio.rewind
+    assert_equal(a, stream.to_a, "dump is #{dump.inspect}")
+  end
+
+  def test_each
+    objects.each do |obj|
+      stream.write obj
+    end
+  
+    sio.rewind
+    dump = sio.read
+    sio.rewind
+    
+    assert_equal(objects, stream.to_a, # <-- #each called by #to_a
+      "dump is #{dump.inspect}")
+  end
+
+  def test_break
+    a = (1..10).to_a
+    a.each do |i|
+      stream.write [i]
+    end
+  
+    sio.rewind
+    
+    a2 = []
+    stream.each do |object|
+      i = object[0]
+      a2 << i
+      break if i == 5
+    end
+    
+    stream.each do |object|
+      i = object[0]
+      a2 << i
+    end
+
+    case type
+    when ObjectStream::MARSHAL_TYPE
+      assert_equal(a, a2)
+    else
+      assert_equal(a[0..4], a2) # fixable?
+    end
+  end
+
+  def test_enum
+    objects.each do |obj|
+      stream.write obj
+    end
+
+    sio.rewind
+
+    enum = stream.each
+    assert_equal(objects, enum.to_a)
+  end
+  
+  def test_read_without_block
+    n = 100
+    n.times do |i|
+      stream << [i]
+    end
+
+    stream.io.rewind
+
+    count = 0
+    until stream.eof?
+      obj = stream.read
+      assert_equal [count], obj
+      count += 1
+    end
+    assert_equal n, count
+  end
+end
+
+class TestBasicMarshal < Minitest::Test
+  include TestBasic
+
+  TYPE = ObjectStream::MARSHAL_TYPE
+  OBJECTS = ADVANCED_OBJECTS + RUBY_OBJECTS
+end
+
+class TestBasicYaml < Minitest::Test
+  include TestBasic
+
+  TYPE = ObjectStream::YAML_TYPE
+  OBJECTS = ADVANCED_OBJECTS + RUBY_OBJECTS
+end
+
+class TestBasicJson < Minitest::Test
+  include TestBasic
+
+  TYPE = ObjectStream::JSON_TYPE
+  OBJECTS = [] # poor json!
+end
+
+class TestBasicMsgpack < Minitest::Test
+  include TestBasic
+
+  TYPE = ObjectStream::MSGPACK_TYPE
+  OBJECTS = ADVANCED_OBJECTS
+end

data/test/test-consume.rb

@@ -0,0 +1,51 @@
+require 'object-stream-wrapper'
+require 'stringio'
+
+require 'minitest/autorun'
+
+class TestConsume < Minitest::Test
+  attr_reader :sio
+
+  def setup
+    @sio = StringIO.new
+  end
+  
+  ObjectStream::TYPES.each do |type|
+    define_method "test_consume_#{type}" do
+      do_test_consume_for type: type
+    end
+  end
+
+  def do_test_consume_for(type: type)
+    n_total = 10
+    n_consumed = 5
+    
+    objects = (0...n_total).map {|i| [i]}
+    
+    stream = ObjectStreamWrapper.new(sio, type: type)
+    objects.each do |object|
+      stream << object
+    end
+    
+    sio.rewind
+    stream = ObjectStreamWrapper.new(sio, type: type)
+    
+    count = 0
+    
+    n_consumed.times do |i|
+      stream.consume do |a|
+        assert_equal(i, a[0])
+        count += 1
+      end
+    end
+    
+    assert_equal(0, sio.pos)
+    
+    stream.each_with_index do |a, i|
+      assert_equal i + n_consumed, a[0]
+      count += 1
+    end
+    
+    assert_equal(n_total, count)
+  end
+end

data/test/test-expect.rb

@@ -0,0 +1,80 @@
+require 'object-stream-wrapper'
+require 'stringio'
+
+require 'minitest/autorun'
+
+class TestExpect < Minitest::Test
+  attr_reader :sio
+  
+  class A
+    def initialize x, y
+      @x, @y = x, y
+    end
+    
+    def to_msgpack pk = nil
+      case pk
+      when MessagePack::Packer
+        pk.write_array_header(2)
+        pk.write @x
+        pk.write @y
+        return pk
+      
+      else # nil or IO
+        MessagePack.pack(self, pk)
+      end
+    end
+    
+    def to_a
+      [@x, @y]
+    end
+    
+    def to_json
+      to_a.to_json
+    end
+    
+    def self.from_serialized ary
+      new *ary
+    end
+    
+    def == other
+      self.class == other.class and
+        to_a == other.to_a
+    end
+  end
+  
+  class B < A
+  end
+
+  def setup
+    @sio = StringIO.new
+  end
+  
+  def test_expect
+    objects = []
+    20.times do |i|
+      if rand < 0.5
+        objects << "A" << A.new(i, i.to_s)
+      else
+        objects << "B" << B.new(i, i.to_s)
+      end
+    end
+    
+    stream = ObjectStreamWrapper.new(sio, type: ObjectStream::MSGPACK_TYPE)
+    objects.each do |object|
+      stream << object
+    end
+    
+    sio.rewind
+    stream = ObjectStreamWrapper.new(sio, type: ObjectStream::MSGPACK_TYPE)
+    objects2 = []
+    stream.read do |object|
+      case object
+      when "A"; stream.expect A
+      when "B"; stream.expect B
+      else stream.unexpect
+      end
+      objects2 << object
+    end
+    assert_equal objects, objects2
+  end
+end

data/test/test-inbox.rb

@@ -0,0 +1,65 @@
+require 'object-stream'
+require 'socket'
+
+require 'minitest/autorun'
+
+class TestInbox < Minitest::Test
+  attr_reader :s, :t
+  
+  def setup
+    @s, @t = UNIXSocket.pair
+  end
+  
+  def test_marshal
+    do_test(ObjectStream::MARSHAL_TYPE)
+  end
+  
+  def test_yaml
+    do_test(ObjectStream::YAML_TYPE)
+  end
+  
+  def test_json
+    do_test(ObjectStream::JSON_TYPE)
+  end
+  
+  def test_msgpack
+    do_test(ObjectStream::MSGPACK_TYPE)
+  end
+  
+  def do_test type
+    n = 200
+    th = Thread.new do
+      src = ObjectStream.new(s, type: type)
+      n.times do |i|
+        src << [i]
+      end
+      src.close
+    end
+
+    dst = ObjectStream.new(t, type: type)
+    i = 0
+
+    begin
+      rand(5).times do
+        assert_equal(i, dst.read[0])
+        i+=1
+      end
+    rescue EOFError
+    end
+
+    begin
+      dst.read do |obj|
+        assert_equal(i, obj[0])
+        i+=1
+      end
+    rescue EOFError
+    end
+
+    dst.each do |obj|
+      assert_equal(i, obj[0])
+      i+=1
+    end
+
+    assert_equal n, i
+  end
+end

data/test/test-maxbuf.rb

@@ -0,0 +1,22 @@
+require 'object-stream'
+require 'stringio'
+
+require 'minitest/autorun'
+
+class TestMaxbuf < Minitest::Test
+  attr_reader :sio, :stream
+  
+  def setup
+    @sio = StringIO.new
+  end
+  
+  def test_maxbuf
+    stream = ObjectStream.new(sio, type: ObjectStream::MSGPACK_TYPE)
+    stream << "a"*20
+    sio.rewind
+    stream = ObjectStream.new(sio, type: ObjectStream::MSGPACK_TYPE, maxbuf: 20)
+    assert_raises(ObjectStream::OverflowError) do
+      stream.to_a
+    end
+  end
+end

data/test/test-outbox.rb

@@ -0,0 +1,35 @@
+require 'object-stream'
+require 'stringio'
+
+require 'minitest/autorun'
+
+class TestOutbox < Minitest::Test
+  attr_reader :sio
+  
+  def setup
+    @sio = StringIO.new
+  end
+
+  def test_outbox_is_lazy
+    stream = ObjectStream.new(sio, type: ObjectStream::MSGPACK_TYPE)
+    stream.write_to_outbox "foo"
+    sio.rewind
+    assert_empty sio.read
+  end
+
+  def test_outbox_precedes
+    stream = ObjectStream.new(sio, type: ObjectStream::MSGPACK_TYPE)
+    n_foo = stream.max_outbox+10
+
+    n_foo.times do |i|
+      stream.write_to_outbox "foo#{i}"
+    end
+    stream.write "bar"
+    sio.rewind
+
+    stream = ObjectStream.new(sio, type: ObjectStream::MSGPACK_TYPE)
+    items = stream.to_a
+    assert_equal n_foo + 1, items.size
+    assert_equal "bar", items.last
+  end
+end

data/test/test-slow-sender.rb

@@ -0,0 +1,79 @@
+require 'object-stream'
+require 'socket'
+require 'stringio'
+
+require 'minitest/autorun'
+
+class TestSlowSender < Minitest::Test
+  attr_reader :s, :t
+  
+  def setup
+    @s, @t = UNIXSocket.pair
+  end
+  
+  def test_marshal
+    assert_equal(:block, get_test_result(ObjectStream::MARSHAL_TYPE))
+  end
+  
+  def test_yaml
+    assert_equal(:block, get_test_result(ObjectStream::YAML_TYPE))
+  end
+  
+  def test_json
+    assert_equal(:noblock, get_test_result(ObjectStream::JSON_TYPE))
+  end
+  
+  def test_msgpack
+    assert_equal(:noblock, get_test_result(ObjectStream::MSGPACK_TYPE))
+  end
+  
+  def get_test_result type
+    pid = fork do
+      sio = StringIO.new
+      stream = ObjectStream.new(sio, type: type)
+      10.times do |i|
+        stream << "foo bar #{i}"
+      end
+
+      sio.rewind
+      data = sio.read
+      pos = data.index "bar 5"
+      raise unless pos < data.size - 10 # assume strings not munged
+      s.write data[0...pos]
+      sleep 0.1
+      s.write data[pos...pos+1]
+      sleep 0.1
+      s.write data[pos+1...pos+2]
+      sleep 0.1
+      s.write data[pos+2..-1]
+    end
+
+    s.close
+    stream = ObjectStream.new(t, type: type)
+
+    select_count = 0
+    empty_read_count = 0
+    until stream.eof?
+      select_count += 1
+      select([stream])
+
+      obj_count = 0
+      stream.read do |obj|
+        obj_count += 1
+      end
+      if obj_count == 0
+        empty_read_count += 1
+      end
+    end
+
+    stream.close
+    if select_count > 1 and empty_read_count > 0
+      :noblock
+    else
+      :block
+    end
+
+  ensure
+    Process.wait pid if pid
+  end
+end