fraggle 0.4.0 → 1.0.0pre

data/test/fraggle_protocol_test.rb

@@ -1,20 +1,12 @@
-require 'fraggle/client'
-require 'fraggle/protocol'
-require 'fraggle/response'
-require 'fraggle/test'
+require File.dirname(__FILE__)+"/helper"
+require 'fraggle/connection'
 
 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
+    @cn  = TestConn.new("127.0.0.1:0")
   end
 
   def encode(req)
@@ -23,31 +15,31 @@ class FraggleProtocolTest < Test::Unit::TestCase
   end
 
   def test_simple
-    req = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
     cn.receive_data(encode(req))
 
-    assert_equal [req], cn
+    assert_equal [req], cn.received
   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
+    a = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOP, :flags => F::VALID
     cn.receive_data(encode(a) + encode(b))
 
-    assert_equal [a, b], cn
+    assert_equal [a, b], cn.received
   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
+    a = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
+    b = Fraggle::Response.new :tag => 1, :verb => V::NOP, :flags => F::VALID
     cn.receive_data(encode(a))
     cn.receive_data(encode(b))
 
-    assert_equal [a, b], cn
+    assert_equal [a, b], cn.received
   end
 
   def test_small_chunks
-    req = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
 
     bytes = encode(req) * 3
     len   = bytes.length
@@ -57,11 +49,11 @@ class FraggleProtocolTest < Test::Unit::TestCase
       cn.receive_data(data)
     end
 
-    assert_equal [req, req, req], cn
+    assert_equal [req, req, req], cn.received
   end
 
   def test_big_chunks
-    req = Fraggle::Response.new :tag => 0, :verb => V::NOOP, :flags => F::VALID
+    req = Fraggle::Response.new :tag => 0, :verb => V::NOP, :flags => F::VALID
 
     bytes = encode(req) * 3
     len   = bytes.length
@@ -71,30 +63,26 @@ class FraggleProtocolTest < Test::Unit::TestCase
       cn.receive_data(data)
     end
 
-    assert_equal [req, req, req], cn
+    assert_equal [req, req, req], cn.received
   end
 
   def test_send_request
-    c = Class.new do
-      include Fraggle::Client
-
-      attr_reader :data
-
-      def initialize
-        @data = ""
-        super(["127.0.0.1:8046"])
-      end
+    req   = Fraggle::Request.new :tag => 0, :verb => V::NOP
+    bytes = req.encode
+    head  = [bytes.length].pack("N")
+    exp   = head+bytes
 
-      def send_data(data)
-        @data << data
+    got = ""
+    (class << cn ; self ; end).instance_eval do
+      define_method(:send_data) do |data|
+        got << data
       end
-    end.new
+    end
 
-    req   = c.noop
-    bytes = req.encode
-    head  = [bytes.length].pack("N")
+    nop = Fraggle::Request.new :verb => V::NOP
+    cn.send_request(nop)
 
-    assert_equal head+bytes, c.data
+    assert_equal head+bytes, got
   end
 
 end

data/test/fraggle_test.rb

@@ -1,16 +1,11 @@
 require 'fraggle'
 
 class FraggleTest < Test::Unit::TestCase
-  def test_addrs_for
-    uri   = "doozer:?ca=ec2-123:9999&ca=127.0.0.1:8888"
-    addrs = Fraggle.addrs_for(uri)
-    assert_equal ["ec2-123:9999", "127.0.0.1:8888"], addrs
-  end
 
-  def test_addrs_for_error
-    uri   = "doozer:?"
-    assert_raises Fraggle::NoAddrs do
-      Fraggle.addrs_for(uri)
-    end
+  def test_uri
+    uri = "doozerd:?ca=1:1&ca=2:2&ca=3:3&ignore=this"
+    addrs = Fraggle.uri(uri)
+    assert_equal ["1:1", "2:2", "3:3"], addrs
   end
+
 end

data/test/fraggle_transaction_test.rb

@@ -0,0 +1,220 @@
+require File.dirname(__FILE__)+"/helper"
+require 'fraggle/connection'
+
+class FraggleTransactionTest < Test::Unit::TestCase
+
+  attr_reader :cn, :tmp, :valid, :done, :error
+
+  def nop(attrs={})
+    request(V::NOP, attrs)
+  end
+
+  def setup
+    @cn = TestConn.new("127.0.0.1:0")
+  end
+
+  def test_tagging
+    req, _ = nop
+    assert_equal 0, cn.send_request(req).tag
+    req, _ = nop
+    assert_equal 1, cn.send_request(req).tag
+    req, _ = nop
+    assert_equal 2, cn.send_request(req).tag
+  end
+
+  def test_valid
+    req, log =  nop
+    req = cn.send_request(req)
+
+    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID
+    cn.receive_response(res)
+
+    assert_equal [res], log.valid
+    assert_equal [], log.done
+  end
+
+  def test_done
+    req, log = nop
+    req = cn.send_request(req)
+
+    res = Fraggle::Response.new :tag => req.tag, :flags => F::DONE
+    cn.receive_response(res)
+
+    assert_equal [], log.valid
+    assert_equal [req], log.done
+  end
+
+  def test_valid_and_done
+    req, log = nop
+    req = cn.send_request(req)
+
+    res = Fraggle::Response.new :tag => req.tag, :flags => F::VALID|F::DONE
+    cn.receive_response(res)
+
+    assert_equal [res], log.valid
+    assert_equal [req], log.done
+  end
+
+  def test_error
+    req, log = nop
+    req = cn.send_request(req)
+
+    res = Fraggle::Response.new(
+      :tag => req.tag,
+      :flags => F::VALID|F::DONE,
+      :err_code => E::OTHER
+    )
+
+    cn.receive_response(res)
+
+    assert_equal [], log.valid
+    assert_equal [], log.done
+    assert_equal [res], log.error
+  end
+
+  def test_invalid_tag
+    res = Fraggle::Response.new(
+      :tag => 0,
+      :flags => F::VALID|F::DONE,
+      :err_code => E::OTHER
+    )
+
+    assert_nothing_raised do
+      cn.receive_response(res)
+    end
+  end
+
+  def test_done_deletes_callback
+    req, log = nop
+    req = cn.send_request(req)
+
+    res = Fraggle::Response.new(:tag => req.tag, :flags => F::VALID|F::DONE)
+    cn.receive_response(res)
+
+    # This should be ignored
+    cn.receive_response(res)
+
+    assert_equal [res], log.valid
+  end
+
+  def test_error_with_done_deletes_callback
+    req, log = nop
+    req = cn.send_request(req)
+
+    res = Fraggle::Response.new(
+      :tag => req.tag,
+      :flags => F::VALID|F::DONE,
+      :err_code => E::OTHER
+    )
+
+    cn.receive_response(res)
+
+    # This should be ignored
+    cn.receive_response(res)
+
+    assert_equal [res], log.error
+  end
+
+  def test_cannot_reuse_sent_request
+    req, _ = nop
+    req = cn.send_request(req)
+
+    assert_raises Fraggle::Connection::SendError do
+      cn.send_request(req)
+    end
+  end
+
+  def test_cancel
+    req, _ = nop
+    req = cn.send_request(req)
+    can = req.cancel
+
+    canx = Fraggle::Response.new(:tag => can.tag, :flags => F::VALID|F::DONE)
+    cn.receive_response(canx)
+  end
+
+  def test_cannot_cancel_more_than_once
+    req, _ = nop
+    req = cn.send_request(req)
+    req.cancel
+
+    assert_raises Fraggle::Connection::SendError do
+      req.cancel
+    end
+  end
+
+  def test_cancel_emits_done
+    req, log = nop
+    req = cn.send_request(req)
+    can = req.cancel
+
+    canx = Fraggle::Response.new(:tag => can.tag, :flags => F::VALID|F::DONE)
+    cn.receive_response(canx)
+
+    assert_equal [req], log.done
+  end
+
+  def test_disconnected
+    a, al = nop
+    a = cn.send_request(a)
+    b, bl = nop
+    b = cn.send_request(b)
+    c, cl = nop
+    c = cn.send_request(c)
+
+    cn.unbind
+
+    assert_equal 1, al.error.length
+    assert_equal nil, al.error.first
+
+    assert_equal 1, bl.error.length
+    assert_equal nil, bl.error.first
+
+    assert_equal 1, cl.error.length
+    assert_equal nil,  cl.error.first
+  end
+
+  def test_send_request_in_error_state
+    cn.err = true
+
+    req, log = nop
+    req = cn.send_request(req)
+    assert_equal nil, req.tag
+
+    assert_equal nil, log.error.first
+  end
+
+  def test_liveness
+    live = cn.post_init
+
+    def cn.timer(_, &blk)
+      blk.call
+    end
+
+    res = Fraggle::Response.new(:tag => live.tag, :rev => 1, :flags => F::VALID|F::DONE)
+    cn.receive_response(res)
+    assert ! cn.err?
+
+    # Connections reuse tags and we're only responding to one request in this
+    # test, so we know the next rev will use the previous tag
+    res = Fraggle::Response.new(:tag => live.tag, :rev => 2, :flags => F::VALID|F::DONE)
+    cn.receive_response(res)
+    assert ! cn.err?
+  end
+
+  def test_not_alive
+    live = cn.post_init
+
+    def cn.timer(_, &blk)
+      blk.call
+    end
+
+    res = Fraggle::Response.new(:tag => live.tag, :rev => 1, :flags => F::VALID|F::DONE)
+    cn.receive_response(res)
+    assert ! cn.err?
+
+    cn.receive_response(res)
+    assert cn.err?
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,84 @@
+require 'test/unit'
+require 'fraggle/connection'
+
+class TestConn
+  include Fraggle::Connection
+
+  attr_reader :sent, :received
+  attr_writer :err
+
+  def initialize(addr)
+    super(addr)
+    @sent = []
+    @received = []
+    @ticks = []
+  end
+
+  def send_request(req)
+    @sent << super(req)
+    req
+  end
+
+  def receive_response(res)
+    @received << res
+    super(res)
+  end
+
+  def send_data(_)
+  end
+
+  def close_connection
+    unbind
+  end
+
+  # Mimic EMs next_tick
+  def next_tick(&blk)
+    @ticks << blk
+  end
+
+  # Mimic a turn in the reactor
+  def tick!
+    @ticks.each {|blk| blk.call }
+    @ticks.clear
+  end
+
+end
+
+class Test::Unit::TestCase
+
+  V = Fraggle::Request::Verb
+  F = Fraggle::Response
+  E = Fraggle::Response::Err
+
+  Log = Struct.new(:valid, :error, :done)
+
+  def request(verb, attrs={})
+    logable(Fraggle::Request.new(attrs.merge(:verb => verb)))
+  end
+
+  def logable(req)
+    log = Log.new([], [], [])
+    req.valid do |e|
+      log.valid << e
+    end
+    req.done do
+      log.done << req
+    end
+    req.error do |e|
+      log.error << e
+    end
+    [req, log]
+  end
+
+  def reply(tag, attrs={})
+    attrs[:flags] ||= 0
+    attrs[:flags] |= F::VALID
+    Fraggle::Response.new(attrs.merge(:tag => tag))
+  end
+
+  def reply!(tag, attrs={})
+    attrs[:flags] = F::DONE
+    reply(tag, attrs)
+  end
+
+end