fraggle 0.1.1 → 0.2.0

data/test/fraggle_protocol_test.rb

@@ -0,0 +1,100 @@
+require 'fraggle/client'
+require 'fraggle/protocol'
+require 'fraggle/response'
+require 'fraggle/test'
+
+class FraggleProtocolTest < Test::Unit::TestCase
+  include Fraggle::Test
+
+  class TestConn < Array
+    include Fraggle::Protocol
+    alias :receive_response :<<
+  end
+
+  attr_reader :cn
+
+  def setup
+    @cn  = TestConn.new
+  end
+
+  def encode(req)
+    data = req.encode
+    [data.length].pack("N") + data
+  end
+
+  def test_simple
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+    cn.receive_data(encode(req))
+
+    assert_equal [req], cn
+  end
+
+  def test_multiple_single
+    a = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOOP, :flags => F::VALID
+    cn.receive_data(encode(a) + encode(b))
+
+    assert_equal [a, b], cn
+  end
+
+  def test_multiple_double
+    a = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOOP, :flags => F::VALID
+    cn.receive_data(encode(a))
+    cn.receive_data(encode(b))
+
+    assert_equal [a, b], cn
+  end
+
+  def test_small_chunks
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+
+    bytes = encode(req) * 3
+    len   = bytes.length
+
+    0.step(len, 1) do |i|
+      data = bytes.slice!(0, i)
+      cn.receive_data(data)
+    end
+
+    assert_equal [req, req, req], cn
+  end
+
+  def test_big_chunks
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+
+    bytes = encode(req) * 3
+    len   = bytes.length
+
+    0.step(len, len/2) do |i|
+      data = bytes.slice!(0, i)
+      cn.receive_data(data)
+    end
+
+    assert_equal [req, req, req], cn
+  end
+
+  def test_send_request
+    c = Class.new do
+      include Fraggle::Client
+
+      attr_reader :data
+
+      def initialize
+        @data = ""
+        super("doozer://127.0.0.1:8046")
+      end
+
+      def send_data(data)
+        @data << data
+      end
+    end.new
+
+    req   = c.noop
+    bytes = req.encode
+    head  = [bytes.length].pack("N")
+
+    assert_equal head+bytes, c.data
+  end
+
+end

data/test/fraggle_snap_test.rb

@@ -0,0 +1,67 @@
+require 'fraggle/test'
+require 'fraggle/snap'
+
+class FraggleSnapTest < Test::Unit::TestCase
+  include Fraggle::Test
+
+  attr_reader :c, :blk
+
+  def setup
+    cl   = TestClient.new("doozer://127.0.0.1:8046")
+    @c   = Fraggle::Snap.new(1, cl)
+    @blk = Blk.new
+  end
+
+  def test_get
+    req = c.get("/ping", &blk)
+
+    assert_sent req.tag, :verb => V::GET, :id => 1, :path => "/ping"
+    assert_recv reply(req.tag)
+  end
+
+  def test_stat
+    req = c.stat("/ping", &blk)
+
+    assert_sent req.tag, :verb => V::STAT, :id => 1, :path => "/ping"
+    assert_recv reply(req.tag)
+  end
+
+  def test_getdir
+    req = c.getdir("/test", &blk)
+
+    assert_sent req.tag, :verb => V::GETDIR, :path => "/test", :id => 1
+    assert_recv reply(req.tag)
+
+    req = c.getdir("/test", 1, 2, &blk)
+
+    assert_sent req.tag, :verb => V::GETDIR, :path => "/test", :offset => 1, :limit => 2, :id => 1
+    assert_recv reply(req.tag)
+  end
+
+  def test_walk
+    req = c.walk("/letters/*", &blk)
+
+    assert_sent req.tag, :verb => V::WALK, :id => 1, :path => "/letters/*"
+    assert_recv reply(req.tag)
+  end
+
+  def test_other
+    req = c.noop(&blk)
+
+    assert_sent req.tag, :verb => V::NOOP
+    assert_recv reply(req.tag)
+  end
+
+  def test_snap
+    b = nil
+    a = c.snap do |sn|
+      b = sn.get("/ping")
+    end
+
+    reply(a.tag, :id => 99)
+
+    assert_sent a.tag, :verb => V::SNAP
+    assert_sent b.tag, :verb => V::GET, :id => 99, :path => "/ping"
+  end
+
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-25 00:00:00 -08:00
+date: 2011-02-08 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -43,11 +43,20 @@ extra_rdoc_files:
 files: 
 - LICENSE
 - README.md
-- lib/fraggle/proto.rb
+- lib/fraggle/client.rb
+- lib/fraggle/emitter.rb
+- lib/fraggle/logger.rb
+- lib/fraggle/meta.rb
+- lib/fraggle/msg.rb
+- lib/fraggle/protocol.rb
+- lib/fraggle/request.rb
+- lib/fraggle/response.rb
+- lib/fraggle/snap.rb
+- lib/fraggle/test.rb
 - lib/fraggle.rb
-- test/core_test.rb
-- test/live_test.rb
-- test/reconnect_test.rb
+- test/fraggle_client_test.rb
+- test/fraggle_protocol_test.rb
+- test/fraggle_snap_test.rb
 has_rdoc: true
 homepage: http://github.com/bmizerany/fraggle
 licenses: []
@@ -84,6 +93,6 @@ signing_key:
 specification_version: 2
 summary: A Ruby/EventMachine Client for Doozer
 test_files: 
-- test/core_test.rb
-- test/live_test.rb
-- test/reconnect_test.rb
+- test/fraggle_client_test.rb
+- test/fraggle_protocol_test.rb
+- test/fraggle_snap_test.rb

data/test/core_test.rb

@@ -1,215 +0,0 @@
-require 'fraggle'
-
-##
-# This is used to test core functionality that the live integration tests will
-# rely on.
-class FakeConn
-  include Fraggle
-
-  attr_reader   :sent, :cbx
-  attr_accessor :tag
-
-  def initialize
-    @sent = ""
-    super("127.0.0.1", :assemble => false)
-    post_init
-  end
-
-  def send_data(data)
-    @sent << data
-  end
-end
-
-class CoreTest < Test::Unit::TestCase
-
-  attr_reader :c
-
-  V = Fraggle::Request::Verb
-  F = Fraggle::Response::Flag
-
-  def setup
-    @c = FakeConn.new
-  end
-
-  def reply(attrs={})
-    attrs[:tag] = c.tag
-    attrs[:flags] ||= 0
-    attrs[:flags] |= F::VALID
-    res = Fraggle::Response.new(attrs)
-    c.receive_response(res)
-    res
-  end
-
-  def reply!(attrs={})
-    attrs[:flags] = F::DONE
-    reply(attrs)
-  end
-
-  def test_sending_data
-    c.call(V::NOOP)
-
-    req = Fraggle::Request.new(
-      :tag   => c.tag,
-      :verb  => V::NOOP
-    )
-
-    buf = req.encode
-    pre = [buf.length].pack("N")
-
-    assert_equal pre+buf, c.sent
-  end
-
-  def test_receive_small_buffered_data
-    count = 0
-
-    tag = c.call(V::WATCH, :path => "**") do |e|
-      count += 1
-    end
-
-    res = Fraggle::Response.new(
-      :tag   => tag,
-      :flags => F::VALID
-    )
-
-    exp   = 10
-    buf   = res.encode
-    pre   = [buf.length].pack("N")
-    bytes = (pre+buf)*exp
-
-    # Chunk bytes to receive_data in some arbitrary size
-    0.step(bytes.length, 3) do |n|
-      c.receive_data(bytes.slice!(0, n))
-    end
-
-    assert_equal 10, count
-  end
-
-  def test_receive_large_buffered_data
-    count = 0
-
-    tag = c.call(V::WATCH, :path => "**") do |e|
-      count += 1
-    end
-
-    res = Fraggle::Response.new(
-      :tag   => tag,
-      :flags => F::VALID
-    )
-
-    exp   = 10
-    buf   = res.encode
-    pre   = [buf.length].pack("N")
-    bytes = (pre+buf)*exp
-
-    c.receive_data(bytes)
-
-    assert_equal 10, count
-  end
-
-  def test_callback_without_done
-    valid = lambda do |e|
-      assert_kind_of Fraggle::Response, e
-    end
-
-    done = lambda do |e|
-      assert false, "Unreachable"
-    end
-
-    tests = [valid, done]
-
-    c.call(V::NOOP) do |e|
-      tests.shift.call(e)
-    end
-    reply!
-
-    assert_equal 1, tests.length
-  end
-
-  def test_callback_with_done
-    valid = lambda do |e, done|
-      assert_kind_of Fraggle::Response, e
-      assert_equal false, done
-    end
-
-    done = lambda do |e, done|
-      assert_nil e
-      assert_equal true, done
-    end
-
-    tests = [valid, done]
-
-    c.call(V::NOOP) do |e, done|
-      tests.shift.call(e, done)
-    end
-
-    reply!
-    assert tests.empty?
-  end
-
-  def test_no_callback
-    c.call(V::NOOP)
-
-    assert_nothing_raised do
-      reply!
-    end
-  end
-
-  def test_no_callback_gc
-    c.call(V::NOOP)
-    reply!
-
-    assert ! c.cbx.has_key?(1)
-  end
-
-  def test_callback_gc
-    c.call(V::NOOP) {}
-    reply
-
-    assert c.cbx.has_key?(c.tag)
-
-    reply!
-
-    assert ! c.cbx.has_key?(c.tag)
-  end
-
-  def test_call_returns_tag
-    assert_equal 0, c.call(V::NOOP)
-    assert_equal 1, c.call(V::NOOP)
-  end
-
-  def test_call_increments_tag
-    c.call(V::NOOP)
-    assert_equal 0, c.tag
-    c.call(V::NOOP)
-    assert_equal 1, c.tag
-    c.call(V::NOOP)
-    assert_equal 2, c.tag
-    c.call(V::NOOP)
-    assert_equal 3, c.tag
-    c.call(V::NOOP)
-    assert_equal 4, c.tag
-    c.call(V::NOOP)
-    assert_equal 5, c.tag
-    c.call(V::NOOP)
-    assert_equal 6, c.tag
-    c.call(V::NOOP)
-    assert_equal 7, c.tag
-    c.call(V::NOOP)
-    assert_equal 8, c.tag
-    c.call(V::NOOP)
-    assert_equal 9, c.tag
-  end
-
-  def test_no_overlap_in_tags
-    c.cbx[0] = Proc.new {}
-    assert_equal 1, c.call(V::NOOP)
-  end
-
-  def test_rollover_tag_when_maxed_out
-    c.tag = Fraggle::MaxInt32
-    c.call(V::NOOP)
-
-    assert_equal  Fraggle::MinInt32, c.tag
-  end
-
-end

data/test/live_test.rb

@@ -1,197 +0,0 @@
-require 'fraggle'
-
-class LiveTest < Test::Unit::TestCase
-  def start(timeout=1, &blk)
-    EM.run do
-      if timeout > 0
-        EM.add_timer(timeout) { fail "Test timeout!" }
-      end
-
-      c = Fraggle.connect(
-        "127.0.0.1:8046",
-        :assemble => false
-      )
-
-      blk.call(c)
-    end
-  end
-
-  def stop
-    EM.stop
-  end
-
-  def test_get
-    start do |c|
-      c.get "/ping" do |e|
-        assert e.ok?, e.err_detail
-        assert e.cas > 0
-        assert_equal "pong", e.value
-        stop
-      end
-    end
-  end
-
-  def test_set
-    start do |c|
-      c.set "/test-set", "a", :clobber do |ea|
-        assert ea.ok?, ea.err_detail
-        assert ea.cas > 0
-        assert_nil ea.value
-
-        c.get "/test-set" do |eb|
-          assert eb.ok?, eb.err_detail
-          assert_equal "a", eb.value
-          stop
-        end
-      end
-    end
-  end
-
-  def test_del
-    start do |c|
-      c.set "/test-del", "a", :clobber do |e|
-        assert e.ok?, e.err_detail
-
-        c.del("/test-del", e.cas) do |de|
-          assert de.ok?, de.err_detail
-          stop
-        end
-      end
-    end
-  end
-
-  def test_error
-    start do |c|
-      c.set "/test-error", "a", :clobber do |ea|
-        assert ! ea.mismatch?
-        assert ea.ok?, ea.err_detail
-        c.set "/test-error", "b", :missing do |eb|
-          assert eb.mismatch?, eb.err_detail
-          stop
-        end
-      end
-    end
-  end
-
-  def test_watch
-    start do |c|
-      count = 0
-      c.watch("/**") do |e|
-        assert e.ok?, e.err_detail
-
-        count += 1
-        if count == 9
-          stop
-        end
-      end
-
-      10.times do
-        EM.next_tick { c.set("/test-watch", "something", :clobber) }
-      end
-    end
-  end
-
-  def test_snap
-    start do |c|
-      c.set "/test-snap", "a", :clobber do |e|
-        assert e.ok?, e.err_detail
-
-        c.snap do |se|
-          assert se.ok?, se.err_detail
-          assert_not_equal 0, se.id
-
-          c.set "/test-snap", "b", :clobber do |e|
-            assert e.ok?, e.err_detail
-
-            c.get "/test-snap", se.id do |ge|
-              assert ge.ok?, ge.err_detail
-              assert_equal "a", ge.value
-              stop
-            end
-          end
-        end
-      end
-    end
-  end
-
-  # TODO:  ???  Shouldn't a deleted snapid produce an error on read?
-  def test_delsnap
-    start do |c|
-      c.snap do |se|
-        assert se.ok?, se.err_detail
-        assert_not_equal 0, se.id
-
-
-        c.delsnap se.id do |de|
-          assert de.ok?, de.err_detail
-
-          c.get "/ping", se.id do |ge|
-            assert ! ge.ok?, ge.err_detail
-            stop
-          end
-        end
-      end
-    end
-  end
-
-  def test_noop
-    start do |c|
-      c.noop do |e|
-        assert e.ok?, e.err_detail
-        stop
-      end
-    end
-  end
-
-  def test_cancel
-    start do |c|
-      tag = c.watch("/test-cancel") do |e, done|
-        if ! done
-          assert e.ok?, e.err_detail
-        end
-
-        if done
-          stop
-        end
-
-        c.cancel(tag)
-      end
-
-      c.set("/test-cancel", "a", :clobber)
-    end
-  end
-
-  def test_walk
-    start do |c|
-
-      exp = [
-        ["/test-walk/1", "a"],
-        ["/test-walk/2", "b"],
-        ["/test-walk/3", "c"]
-      ]
-
-      n = exp.length
-
-      exp.each do |path, val|
-        c.set path, val, :clobber do |e|
-          assert e.ok?, e.err_detail
-          n -= 1
-
-          if n == 0
-            items = []
-            c.walk "/test-walk/*" do |e, done|
-              if done
-                assert_equal exp, items
-                stop
-              else
-                items << [e.path, e.value]
-              end
-            end
-          end
-        end
-      end
-
-    end
-  end
-
-end