stark 0.7.0 → 0.8.0

data/test/test_ruby.rb

@@ -3,25 +3,164 @@ require 'stark'
 require 'stark/ruby'
 
 class TestRuby < Test::Unit::TestCase
-  def test_namespace
-    ast = Stark::Parser.ast <<-EOM
-namespace rb Blah
+  def create_ruby(thrift, options = {})
+    ast = Stark::Parser.ast thrift
+    stream = StringIO.new
+    ruby = Stark::Ruby.new stream
+    options[:skip_prologue] = options[:skip_epilogue] = true if options[:only_ast]
+    stream.string = '' if options[:skip_prologue]
+    if options[:skip_epilogue]
+      ast.each { |a| a.accept ruby }
+    else
+      ruby.run ast
+    end
+    stream.string
+  end
+
+  def create_ns_module(name, lang = 'rb')
+    thrift = <<-EOM
+namespace #{lang} #{name}
 enum Status {
   DEAD
   ALIVE
 }
   EOM
 
-    stream = StringIO.new
-    ruby = Stark::Ruby.new stream
-
-    ruby.run ast
-
     ns = Module.new
 
-    ns.module_eval stream.string
+    ns.module_eval create_ruby(thrift)
+    ns
+  end
 
+  def test_namespace1
+    ns = create_ns_module 'Blah'
     assert ns::Blah
     assert ns::Blah::Enum_Status
   end
+
+  def test_namespace2
+    ns = create_ns_module 'Blah.Blerg'
+    assert ns::Blah::Blerg
+    assert ns::Blah::Blerg::Enum_Status
+  end
+
+  def test_namespace3
+    ns = create_ns_module 'Blah.Blerg', '*'
+    assert ns::Blah::Blerg
+    assert ns::Blah::Blerg::Enum_Status
+  end
+
+  def test_namespace4
+    ns = create_ns_module 'Blah.Blerg', 'c'
+    assert ns::Enum_Status
+  end
+
+  def test_forward_declaration
+    code = <<-EOM
+struct Foo {
+  1: Bar bar
+}
+
+struct Bar {
+  1: i32 ids
+}
+  EOM
+
+    ns = Module.new
+    ns.module_eval create_ruby code
+    assert ns::Foo
+    assert ns::Bar
+  end
+
+  def test_struct_attr_accessor
+    ruby = create_ruby <<-EOM, :only_ast => true
+struct Foo {
+1:string str
+2:map<string,string> map
+3:i32 int
+}
+EOM
+    assert ruby =~ %r{class\sFoo\s<\sStark::Struct
+                       .*
+                      attr_accessor\s:str
+                       .*
+                      attr_accessor\s:map
+                       .*
+                      attr_accessor\s:int}mx, "did not match:\n#{ruby}"
+    ns = Module.new
+    ns.module_eval ruby
+    fields = ns::Foo.fields
+    assert_equal({ 1 => :str, 2 => :map, 3 => :int }, fields)
+  end
+
+  def test_struct_set_field_number
+    ruby = create_ruby <<-EOM, :only_ast => true
+struct Foo {
+3:string str
+2:map<string,string> map
+1:i32 int
+}
+EOM
+
+    assert ruby =~ %r{class\sFoo\s<\sStark::Struct
+                       .*
+                      field_number\s3
+                       .*
+                      attr_accessor\s:str
+                       .*
+                      field_number\s2
+                       .*
+                      attr_accessor\s:map
+                       .*
+                      field_number\s1
+                       .*
+                      attr_accessor\s:int}mx, "did not match:\n#{ruby}"
+    ns = Module.new
+    ns.module_eval ruby
+    fields = ns::Foo.fields
+    assert_equal({ 3 => :str, 2 => :map, 1 => :int }, fields)
+  end
+
+  def test_to_struct_to_hash
+    ruby = create_ruby <<-EOM, :only_ast => true
+struct Foo {
+1:string str
+2:map<string,string> map
+3:i32 int
+}
+EOM
+
+    ns = Module.new
+    ns.module_eval ruby
+    assert ns::Foo
+
+    foo = ns::Foo.new :str => "hi", :int => 20
+    assert_equal({:str => "hi", :int => 20}, foo.to_hash)
+  end
+
+  def test_to_struct_aref
+    ruby = create_ruby <<-EOM, :only_ast => true
+struct Foo {
+1:string str
+2:map<string,string> map
+3:i32 int
+}
+EOM
+
+    ns = Module.new
+    ns.module_eval ruby
+    assert ns::Foo
+
+    foo = ns::Foo.new :str => "hi", :int => 20
+    assert_equal "hi", foo["str"]
+    assert_equal "hi", foo[:str]
+    assert_equal "hi", foo[1]
+    assert_equal 20,   foo["int"]
+    assert_equal 20,   foo[:int]
+    assert_equal 20,   foo[3]
+    assert_equal ["hi", nil, 20], foo[1..3]
+    assert_equal ["hi", 20], foo[1, 3]
+    assert_equal ["hi", 20], foo[:str, :int]
+  end
+
 end

data/test/test_server.rb

@@ -5,99 +5,27 @@ require 'stark'
 require 'rubygems'
 require 'thrift'
 
-Thread.abort_on_exception = true
+require 'test/test_helper'
 
 class TestServer < Test::Unit::TestCase
-  def setup
-    @client_t, @server_t = Stark.pipe_transport
-    @client_p = Thrift::BinaryProtocol.new @client_t
-    @server_p = Thrift::BinaryProtocol.new @server_t
-
-    @n = Module.new
-    Stark.materialize "test/profile.thrift", @n
-
-    @client = @n::UserStorage::Client.new @client_p, @client_p
-    @handler = Handler.new @n
-    @server = @n::UserStorage::Processor.new @handler
-  end
-
-  def teardown
-    @client_t.close
-    @server_t.close
-  end
-
-  class Handler
-    def initialize(n)
-      @users = {}
-      @last_map = nil
-      @last_list = nil
-      @last_status = nil
-      @n = n
-      @user_status = nil
-    end
-
-    attr_accessor :last_map, :last_list, :last_status, :user_status
-
-    def store(obj)
-      @users[obj.uid] = obj
-    end
-
-    def retrieve(id)
-      @users[id]
-    end
-
-    def set_map(m)
-      @last_map = m
-    end
-
-    def set_list(l)
-      @last_list = l
-    end
-
-    def set_status(s)
-      @last_status = s
-    end
-
-    def volume_up
-      raise @n::RockTooHard.new('volume' => 11)
-    end
+  IDL = "test/profile.thrift"
+  SERVICE = "UserStorage"
+  include TestHelper
 
-    def make_bitcoins
-      sleep 2
-    end
-
-    def add(a,b)
-      a + b
-    end
-
-    def set_user_status(s)
-      @user_status = s
-    end
-
-    attr_accessor :user_relationship
-    def set_user_relationship(rel)
-      @user_relationship = rel
-    end
+  def setup
+    setup_server
   end
 
   def test_store_and_retrieve
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    xuser = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
-
-    @client.store xuser
+    send_to_server do
+      xuser = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
 
-    st.join
-
-    st = Thread.new do
-      @server.process @server_p, @server_p
+      @client.store xuser
     end
 
-    obj = @client.retrieve 0
-
-    st.join
+    obj = send_to_server do
+      @client.retrieve 0
+    end
 
     assert_equal 0, obj.uid
     assert_equal "root", obj.name
@@ -105,215 +33,171 @@ class TestServer < Test::Unit::TestCase
   end
 
   def test_set_map
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    m = { "blah" => "foo", "a" => "b" }
+    send_to_server do
+      m = { "blah" => "foo", "a" => "b" }
 
-    @client.set_map m
-
-    st.join
+      @client.set_map m
+    end
 
     assert_equal "foo", @handler.last_map["blah"]
     assert_equal "b", @handler.last_map["a"]
   end
 
   def test_last_map
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    @handler.last_map = { "blah" => "foo", "a" => "b" }
-
-    m = @client.last_map
+    m = send_to_server do
+      @handler.last_map = { "blah" => "foo", "a" => "b" }
 
-    st.join
+      @client.last_map
+    end
 
     assert_equal "foo", m["blah"]
     assert_equal "b", m["a"]
   end
 
   def test_set_list
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
     m = [ "blah", "foo", "a", "b" ]
+    send_to_server do
 
-    @client.set_list m
-
-    st.join
+      @client.set_list m
+    end
 
     assert_equal m, @handler.last_list
   end
 
   def test_last_list
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
+    send_to_server do
+      l = [ "blah", "foo", "a", "b" ]
+      @handler.last_list = l
 
-    l = [ "blah", "foo", "a", "b" ]
-    @handler.last_list = l
-
-    assert_equal l, @client.last_list
-
-    st.join
+      assert_equal l, @client.last_list
+    end
   end
 
   def test_last_list_is_nil
-    st = Thread.new do
-      @server.process @server_p, @server_p
+    send_to_server do
+      assert_equal nil, @client.last_list
     end
-
-    assert_equal [], @client.last_list
-
-    st.join
   end
 
   def test_enum
-    st = Thread.new do
-      @server.process @server_p, @server_p
+    send_to_server do
+      @client.set_status :ON
     end
 
-    @client.set_status :ON
-
-    st.join
-
     assert_equal :ON, @handler.last_status
   end
 
   def test_enum_recv
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    @handler.last_status = :ON
-
-    assert_equal :ON, @client.last_status
+    send_to_server do
+      @handler.last_status = :ON
 
-    st.join
+      assert_equal :ON, @client.last_status
+    end
   end
 
   def test_throw
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    e = assert_raises @n::RockTooHard do
-      @client.volume_up
+    e = send_to_server do
+      assert_raises @n::RockTooHard do
+        @client.volume_up
+      end
     end
 
-    st.join
-
     assert_equal 11, e.volume
   end
 
-  # Thread.abort_on_exception = true
-
   def test_oneway
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
+    send_to_server do
+      t = Time.now
 
-    t = Time.now
+      Timeout.timeout 3 do
+        assert_equal nil, @client.make_bitcoins
+      end
 
-    Timeout.timeout 3 do
-      assert_equal nil, @client.make_bitcoins
+      assert Time.now - t < 0.1
     end
-
-    assert Time.now - t < 0.1
-
-    st.join
   end
 
   def test_2args
-    st = Thread.new do
-      @server.process @server_p, @server_p
+    send_to_server do
+      assert_equal 7, @client.add(3, 4)
     end
-
-    assert_equal 7, @client.add(3, 4)
-
-    st.join
   end
 
   def test_read_struct_in_a_struct
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    prof = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
-    stat = @n::UserStatus.new 'profile' => prof, 'active' => true
+    send_to_server do
+      prof = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
+      stat = @n::UserStatus.new 'profile' => prof, 'active' => true
 
-    @handler.user_status = stat
+      @handler.user_status = stat
 
-    status = @client.user_status
+      status = @client.user_status
 
-    assert_equal true, status.active
-    
-    prof = status.profile
+      assert_equal true, status.active
 
-    assert_equal 0, prof.uid
-    assert_equal "root", prof.name
-    assert_equal "god", prof.blurb
+      prof = status.profile
 
-    st.join
+      assert_equal 0, prof.uid
+      assert_equal "root", prof.name
+      assert_equal "god", prof.blurb
+    end
   end
 
   def test_write_struct_in_a_struct
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    prof = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
-    stat = @n::UserStatus.new 'profile' => prof, 'active' => true
+    send_to_server do
+      prof = @n::UserProfile.new 'uid' => 0, 'name' => 'root', 'blurb' => 'god'
+      stat = @n::UserStatus.new 'profile' => prof, 'active' => true
 
-    @client.set_user_status stat
+      @client.set_user_status stat
 
-    status = @handler.user_status
+      status = @handler.user_status
 
-    assert_equal true, status.active
-    
-    prof = status.profile
+      assert_equal true, status.active
 
-    assert_equal 0, prof.uid
-    assert_equal "root", prof.name
-    assert_equal "god", prof.blurb
+      prof = status.profile
 
-    st.join
+      assert_equal 0, prof.uid
+      assert_equal "root", prof.name
+      assert_equal "god", prof.blurb
+    end
   end
 
   def test_read_enum_in_struct
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
-
-    stat = @n::UserRelationship.new 'user' => 0, 'status' => :ITS_COMPLICATED
+    send_to_server do
+      stat = @n::UserRelationship.new 'user' => 0, 'status' => :ITS_COMPLICATED
 
-    @handler.user_relationship = stat
+      @handler.user_relationship = stat
 
-    rel = @client.user_relationship
+      rel = @client.user_relationship
 
-    assert_equal 0, rel.user
-    assert_equal :ITS_COMPLICATED, rel.status
-
-    st.join
+      assert_equal 0, rel.user
+      assert_equal :ITS_COMPLICATED, rel.status
+    end
   end
 
   def test_write_enum_in_struct
-    st = Thread.new do
-      @server.process @server_p, @server_p
-    end
+    send_to_server do
 
-    stat = @n::UserRelationship.new 'user' => 0, 'status' => :ITS_COMPLICATED
+      stat = @n::UserRelationship.new 'user' => 0, 'status' => :ITS_COMPLICATED
 
-    @client.set_user_relationship stat
+      @client.set_user_relationship stat
 
-    rel = @handler.user_relationship
+      rel = @handler.user_relationship
 
-    assert_equal 0, rel.user
-    assert_equal :ITS_COMPLICATED, rel.status
+      assert_equal 0, rel.user
+      assert_equal :ITS_COMPLICATED, rel.status
+    end
+  end
 
-    st.join
+  def test_exception_raised
+    set_handler Object.new.tap {|h| def h.respond_to?(*); true; end}
+
+    e = send_to_server do
+      assert_raises Thrift::ApplicationException do
+        @client.last_status
+      end
+    end
+    assert e.type == Thrift::ApplicationException::INTERNAL_ERROR
+    assert e.message =~ /undefined method/
+    assert @log_stream.string =~ /undefined method/
   end
 end