liveresource 2.0.0

data/test/declarations_test.rb

@@ -0,0 +1,119 @@
+require_relative 'test_helper'
+
+class TestClass < Test::Unit::TestCase
+  class Class1
+    include LiveResource::Resource
+
+    @@class_attr = 42
+
+    remote_reader :name
+    remote_writer :write_only
+    remote_accessor :accessor
+
+    resource_name :name
+    resource_class :class_1
+
+    def initialize(name)
+      remote_attribute_write(:name, name)
+
+      self.write_only = 'not yet written'
+      self.accessor = nil
+    end
+
+    def self.class_method1(param1, param2)
+      (param1 + param2).upcase
+    end
+
+    def method1(param1, param2)
+      name + param1 + param2
+    end
+
+    def self.class_attr
+      @@class_attr
+    end
+
+    def self.class_attr=(new_value)
+      @@class_attr = new_value
+    end
+
+    def self.private_class_method1
+    end
+    private_class_method :private_class_method1
+
+    private
+
+    def private_method1
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    LiveResource::RedisClient.logger.level = Logger::INFO
+
+    # Class resources
+    LiveResource::register Class1
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_correct_class_methods
+    assert_equal [:new, :ruby_new, :class_method1, :class_attr, :class_attr=].sort,
+    Class1.remote_methods.sort
+  end
+
+  # TODO: support class attributes (?)
+  # def test_correct_class_attributes
+  #   assert_equal [:class_attr], Class1.remote_attributes
+  # end
+
+  def test_correct_instance_methods
+    assert_equal [:method1], Class1.ruby_new("foo").remote_methods
+  end
+
+  def test_correct_instance_attributes
+    assert_equal [:name, :write_only=, :accessor, :accessor=].sort,
+    Class1.ruby_new("foo").remote_attributes.sort
+  end
+
+  def test_call_class_method
+    class_resource = LiveResource::find(:class_1)
+
+    assert class_resource.respond_to? :new
+    assert class_resource.respond_to? :class_method1
+
+    assert_equal "FOOBAR", class_resource.class_method1("foo", "bar")
+  end
+
+  def test_create_instances
+    class_resource = LiveResource::find(:class_1)
+
+    assert_equal 0, LiveResource::all(:class_1).length
+
+    class_resource.new("bob")
+    class_resource.new("fred")
+    class_resource.new("sue")
+
+    assert_equal 3, LiveResource::all(:class_1).length
+  end
+
+  def test_new_returns_resource_proxy
+    class_resource = LiveResource::find(:class_1)
+    bob = class_resource.new("bob")
+
+    assert_equal "bob jones", bob.method1(" ", "jones")
+  end
+
+  def test_resource_proxy_can_get_attributes
+    class_resource = LiveResource::find(:class_1)
+    bob = class_resource.new("bob")
+
+    assert_equal "bob", bob.name
+    assert_equal nil, bob.accessor
+
+    bob.accessor = "new value"
+    assert_equal "new value", bob.accessor
+  end
+end

data/test/logger_test.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class C
+  include LiveResource::LogHelper
+
+  def initialize
+    @log_backend = StringIO.new("", "r+")
+    self.logger = Logger.new(@log_backend)
+  end
+
+  def generate_debug
+    debug "my debug message"
+  end
+
+  def generate_fatal
+    fatal "my fatal message"
+  end
+
+  def dump
+    @log_backend.rewind
+    @log_backend.readlines
+  end
+end
+
+class LoggerTest < Test::Unit::TestCase
+  def test_basic_logging
+    c = C.new
+    c.generate_fatal
+
+    assert_match "my fatal message", c.dump[0]
+  end
+
+  def test_changing_log_levels
+    c = C.new
+    c.logger.level = Logger::WARN
+
+    c.generate_debug
+    assert_equal 0, c.dump.length
+
+    c.logger.level = Logger::DEBUG
+    c.generate_debug
+    assert_match "my debug message", c.dump[0]
+  end
+end

data/test/method_call_test.rb

@@ -0,0 +1,223 @@
+require_relative 'test_helper'
+
+class MethodTest < Test::Unit::TestCase
+  class MyClass
+    attr_accessor :a, :b
+
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+  end
+
+  # We slice, we dice, we can cut through tin cans!
+  class Server
+    include LiveResource::Resource
+
+    resource_class :server
+    resource_name :object_id
+
+    def meaning
+      42
+    end
+
+    def upcase(str)
+      str.upcase
+    end
+
+    def slow_upcase(str)
+      10.times { Thread.pass }
+      str.upcase
+    end
+
+    def two_second_upcase(str)
+      sleep 2
+      str.upcase
+    end
+
+    def add(a, b)
+      a + b
+    end
+
+    def reverse(arr)
+      arr.reverse
+    end
+
+    def swap_a_b(myclass)
+      a, b = myclass.a, myclass.b
+      myclass.b = a
+      myclass.a = b
+      myclass
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    Server.new
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  # TODO: some test like this
+  #
+  # def test_method_done
+  #   rs = LiveResource::RedisSpace.new('test')
+  #
+  #   assert_raise(ArgumentError) do
+  #     rs.method_done? '1' # Doesn't exist yet
+  #   end
+  #
+  #   rs.method_push '1'
+  #   assert_equal false, rs.method_done?('1')
+  #
+  #   rs.method_wait
+  #   assert_equal false, rs.method_done?('1')
+  #
+  #   rs.result_set '1', 42
+  #   rs.method_done '1'
+  #   assert_equal true, rs.method_done?('1')
+  # end
+
+  def test_synchronous_method
+    starting_keys = Redis.new.dbsize
+    client = LiveResource::any(:server)
+
+    # Zero parameters
+    assert_equal 42, client.meaning
+
+    # One parameter (simple)
+    assert_equal "FOOBAR", client.upcase("foobar")
+
+    # One parameter (complex)
+    assert_equal [3, 2, 1], client.reverse([1, 2, 3])
+
+    # Two parameters
+    assert_equal 3, client.add(1, 2)
+
+    # Non-native class
+    myclass = client.swap_a_b MyClass.new("a", "b")
+    assert_equal "b", myclass.a
+    assert_equal "a", myclass.b
+
+    # Should have no junk left over in Redis
+    assert_equal starting_keys, Redis.new.dbsize
+  end
+
+  def test_method_with_no_response
+    starting_keys = Redis.new.dbsize
+    client = LiveResource::any(:server)
+
+    # Do one async call; dispatcher should auto-clean up
+    client.upcase! "foobar"
+
+    # Do a sync call afterward to make sure the first is done
+    client.upcase "foobar"
+
+    assert_equal starting_keys, Redis.new.dbsize
+  end
+
+  def test_no_matching_method
+    client = LiveResource::any(:server)
+
+    assert_raise(NoMethodError) do
+      client.this_is_not_a_valid_method
+    end
+  end
+
+  def test_method_stress
+    starting_keys = Redis.new.dbsize
+    client = LiveResource::any(:server)
+
+    100.times do
+      client.upcase("foobar")
+    end
+
+    # Should have no junk left over in Redis
+    assert_equal starting_keys, Redis.new.dbsize
+  end
+
+  def test_method_call_with_future
+    starting_keys = Redis.new.dbsize
+    client = LiveResource::any(:server)
+
+    value = client.slow_upcase? 'foobar'
+
+    assert_not_nil value
+    assert_equal false, value.done?
+
+    # Wait for valid result.
+    assert_equal 'FOOBAR', value.value
+
+    # Should have no junk left over in Redis, BUT we can still get the
+    # future's value as many times as we want.
+    assert_equal starting_keys, Redis.new.dbsize
+    assert_equal 'FOOBAR', value.value
+  end
+
+  # Similar test to above, but in this case we don't wait for done until
+  # after we already know the action is done.
+  def test_wait_for_done_after_done
+    client = LiveResource::any(:server)
+
+    # Repeat a bunch of times -- this helps catch a race
+    # condition in done_with?
+    100.times do
+      value = client.slow_upcase? 'foobar'
+
+      while !value.done?
+        Thread.pass
+      end
+
+      # Result should be ready for us
+      assert_equal 'FOOBAR', value.value
+    end
+  end
+
+  def test_method_timeout_success
+    client = LiveResource::any(:server)
+    value = client.upcase? "foobar"
+
+    assert_equal "FOOBAR", value.value(1)
+  end
+
+  def test_method_timeout_failure
+    client = LiveResource::any(:server)
+
+    LiveResource::stop # No servers
+
+    starting_keys = Redis.new.dbsize
+
+    assert_raise(RuntimeError) do
+      value = client.upcase? "foobar"
+      value.value(1)
+    end
+
+    # Should have no junk left over in Redis
+    assert_equal starting_keys, Redis.new.dbsize
+  end
+
+  def test_method_completes_after_timeout
+    starting_keys = Redis.new.dbsize
+    client = LiveResource::any(:server)
+
+    # Turn up log level; this test will generate an appropriate warning.
+    old_level = LiveResource::RedisClient.logger.level = Logger::ERROR
+
+    # This will fail (as above) but the server will actually complete it a second
+    # later. Need to make sure server cleans up ok.
+    assert_raise(RuntimeError) do
+      value = client.two_second_upcase? "foobar"
+      value.value(1)
+    end
+
+    sleep 2
+
+    # Should have no junk left over in Redis
+    assert_equal starting_keys, Redis.new.dbsize
+
+    LiveResource::RedisClient.logger.level = old_level
+  end
+end

data/test/method_forward_continue_test.rb

@@ -0,0 +1,83 @@
+require_relative 'test_helper'
+
+class ForwardContinueTest < Test::Unit::TestCase
+  class Class1
+    include LiveResource::Resource
+
+    resource_name :object_id
+    resource_class :class_1
+
+    def method1(param1, param2)
+      c2 = LiveResource::any(:class_2)
+      c3 = LiveResource::any(:class_3)
+      param3 = "baz"
+
+      forward(c2, :method2, param1, param2, param3).continue(c3, :method3)
+    end
+  end
+
+  class Class2
+    include LiveResource::Resource
+
+    resource_name :object_id
+    resource_class :class_2
+
+    def method2(param1, param2, param3)
+      [param1, param2, param3].join('-')
+    end
+  end
+
+  class Class3
+    include LiveResource::Resource
+
+    resource_name :object_id
+    resource_class :class_3
+
+    def method3(param1)
+      param1.upcase
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    Class1.new
+    Class2.new
+    Class3.new
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_instances_have_methods
+    i = LiveResource::all(:class_1).first
+
+    assert i.respond_to?(:method1), "instance does not respond to method1"
+  end
+
+  def test_instances_have_async_methods
+    i = LiveResource::all(:class_1).first
+
+    assert i.respond_to?(:method1!), "instance does not respond to method1!"
+    assert i.respond_to?(:method1?), "instance does not respond to method1?"
+  end
+
+  def test_instance_does_not_respond_to_invalid_methods
+    i = LiveResource::all(:class_1).first
+
+    assert !i.respond_to?(:method2), "instance should not respond to method2"
+    assert !i.respond_to?(:method2!), "instance should not respond to method2!"
+    assert !i.respond_to?(:method2?), "instance should not respond to method2?"
+  end
+
+  def test_message_path
+    starting_keys = Redis.new.dbsize
+
+    # LiveResource::RedisClient::logger.level = Logger::DEBUG
+    assert_equal "FOO-BAR-BAZ", LiveResource::any(:class_1).method1("foo", "bar")
+
+    # Should have no junk left over in Redis
+    assert_equal starting_keys, Redis.new.dbsize
+  end
+end