liveresource 2.0.0

data/old/test/redis_api_test.rb

@@ -0,0 +1,185 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+# These tests verify assumptions about the Redis APIs.
+class RedisApiTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+    @trace = false
+  end
+
+  def trace(s)
+    puts("- #{s}") if @trace
+  end
+  
+  def publisher(channel, quantity)
+    Thread.new do
+      trace "Publisher started"
+      redis = Redis.new
+      
+      quantity.times do |i|
+        trace "Publishing..."
+        redis.publish(channel, "news #{i + 1}")
+      end
+      
+      trace "Publisher done"
+    end
+  end
+    
+  def subscriber(channel, quantity, messages)
+    started = false
+    
+    thread = Thread.new do
+      redis = Redis.new
+
+      redis.subscribe(channel) do |on|
+        on.subscribe do |channel, subscriptions|
+          trace "Subscribed to ##{channel} (#{subscriptions} subscriptions)"
+        end
+        
+        on.message do |channel, message|
+          trace "##{channel}: #{message}"
+          messages << message
+          
+          redis.unsubscribe if (messages.length == quantity)
+        end
+        
+        on.unsubscribe do |channel, subscriptions|
+          trace "Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"
+        end
+
+        trace "Subscriber started"
+        started = true
+      end
+
+      trace "Subscriber done"
+    end
+    
+    Thread.pass while !started
+    
+    thread
+  end
+  
+  def test_publish_subscribe
+    messages = Queue.new
+
+    subscriber = subscriber('test', 1, messages)
+    publisher = publisher('test', 1)
+
+    publisher.join
+    subscriber.join
+
+    assert_equal 'news 1', messages.pop
+  end
+  
+  def consume(list, quantity, values)
+    Thread.new do
+      trace "Consumer started"
+      redis = Redis.new
+
+      quantity.times do
+        trace "Consuming..."
+        list, value = redis.blpop list, 10
+        trace "Consumed: #{value}"
+        values << value
+      end
+
+      trace "Consumer done"
+    end
+  end
+  
+  def produce(list, quantity, delay = 0.0)
+    Thread.new do
+      trace "Producer started"
+      redis = Redis.new
+      
+      quantity.times do
+        sleep(delay) unless (delay == 0.0)
+        
+        trace "Producing..."
+        redis.rpush list, "hello"
+        trace "Produced"
+      end
+
+      trace "Producer done"
+    end
+  end
+  
+  def test_blocking_pop_consumer_starts_first
+    values = Queue.new
+
+    consumer = consume('test', 1, values)
+    sleep 0.1
+    producer = produce('test', 1)
+    
+    consumer.join
+    producer.join
+    
+    assert_equal "hello", values.pop
+  end
+
+  def test_blocking_pop_producer_starts_first
+    values = Queue.new
+
+    producer = produce('test', 1)
+    sleep 0.1
+    consumer = consume('test', 1, values)
+    
+    consumer.join
+    producer.join
+    
+    assert_equal "hello", values.pop
+  end
+
+  def test_blocking_pop_producer_starts_first
+    values = Queue.new
+
+    producer = produce('test', 1)
+    sleep 0.1
+    consumer = consume('test', 1, values)
+    
+    consumer.join
+    producer.join
+    
+    assert_equal "hello", values.pop
+  end
+  
+  def test_blocking_pop_stress
+    values = Queue.new
+
+    producer = produce('test', 1000)
+    consumer = consume('test', 1000, values)
+    
+    consumer.join
+    producer.join
+    
+    assert_equal "hello", values.pop
+  end
+  
+  def test_optimistic_locking
+    redis = Redis.new    
+    redis['key'] = 1;
+
+    # Test successful case
+    redis.watch 'key'
+    val = redis['key'].to_i;
+    val = val + 1;
+    redis.multi
+    redis['key'] = val;
+    exec_return = redis.exec
+    trace "exec (1): #{exec_return.inspect}"
+    assert_not_nil exec_return
+    
+    # Test failure case
+    redis.watch 'key'
+    val = redis['key'].to_i;
+    val = val + 1;
+
+    redis['key'] = 10; # someone else hops in and modifies 'key'
+
+    redis.multi
+    redis['key'] = val;
+    exec_return = redis.exec
+    trace "exec (2): #{exec_return.inspect}"
+    assert_nil exec_return
+  end
+end

data/old/test/simple_attribute_test.rb

@@ -0,0 +1,75 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class FavoriteColorServer
+  include LiveResource::Attribute
+  
+  remote_writer :color
+  remote_accessor :foo, :bar
+  
+  def initialize
+    self.namespace = "colors.favorite"
+  end
+  
+  def start
+    ready = Queue.new
+
+    thread = Thread.new do
+      self.color = 'blue'
+      ready << true
+      sleep 0.1
+      self.color = 'green'
+    end
+    
+    ready.pop
+    thread
+  end
+end
+
+class FavoriteColorClient
+  include LiveResource::Attribute
+
+  remote_reader :color
+    
+  def initialize
+    self.namespace = "colors.favorite"
+  end
+end
+
+class SimpleResourceTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+
+    @client = FavoriteColorClient.new
+    @server = FavoriteColorServer.new
+  end
+  
+  def test_accessors_defined
+    assert @client.respond_to? :color
+    assert @server.respond_to? :color=
+  end
+
+  def test_simple_read_write
+    assert_equal nil, @client.color
+    
+    thread = @server.start
+  
+    assert_equal 'blue', @client.color
+    sleep 0.2
+    assert_equal 'green', @client.color
+    
+    thread.join
+  end
+  
+  def test_accessor
+    assert @server.respond_to? :foo
+    assert @server.respond_to? :foo=
+    assert @server.respond_to? :bar
+    assert @server.respond_to? :bar=
+
+    @server.foo = 'foo'
+    assert_equal 'foo', @server.foo
+    
+    @server.bar = @server.foo
+    assert_equal 'foo', @server.bar
+  end
+end

data/test/attribute_test.rb

@@ -0,0 +1,212 @@
+require_relative 'test_helper'
+
+class AttributeTest < Test::Unit::TestCase
+  class MyClass
+    attr_accessor :a, :b
+
+    def initialize(a, b)
+      @a = a
+      @b = b
+    end
+  end
+
+  class AttributeProvider
+    include LiveResource::Resource
+
+    resource_class :attribute_provider
+    resource_name :object_id
+
+    remote_accessor :string, :integer, :float, :my_class, :nil
+    remote_reader :foo
+
+    def initialize
+      self.string = "string"
+      self.integer = 42
+      self.float = 3.14
+      self.my_class = MyClass.new("foo", 42)
+      self.nil = nil
+    end
+
+    def set_foo(value, overwrite=true)
+      if overwrite
+        remote_attribute_write(:foo, value)
+      else
+        remote_attribute_writenx(:foo, value)
+      end
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    LiveResource::RedisClient.logger.level = Logger::INFO
+
+    AttributeProvider.new
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_string_attribute
+    ap = LiveResource::any(:attribute_provider)
+
+    assert ap.string.kind_of?(String), "String attribute is not a string"
+    assert_equal "string", ap.string
+
+    ap.string = "new string"
+    assert_equal "new string", ap.string
+  end
+
+  def test_numeric_attributes
+    ap = LiveResource::any(:attribute_provider)
+
+    assert ap.integer.kind_of?(Numeric), "Integer attribute is not a numeric"
+    assert ap.float.kind_of?(Numeric), "Float attribute is not a numeric"
+    assert ap.float.kind_of?(Float), "Float attribute is not a float"
+
+    assert_equal 42, ap.integer
+    assert_equal 3.14, ap.float
+
+    ap.integer = 24
+    assert_equal 24, ap.integer
+  end
+
+  def test_custom_attribute
+    ap = LiveResource::any(:attribute_provider)
+    mc = ap.my_class
+
+    assert mc.kind_of?(MyClass), "MyClass attribute is not a MyClass"
+
+    assert_equal "foo", mc.a
+    assert_equal 42, mc.b
+  end
+
+  def test_nil_attribute
+    ap = LiveResource::any(:attribute_provider)
+
+    assert_equal nil, ap.nil
+  end
+
+  def test_no_overwrite
+    ap = LiveResource::any(:attribute_provider)
+
+    # Foo should be not set.
+    assert_equal nil, ap.foo
+
+    # Set it for the first time, telling it not overwrite. This should work, as it
+    # has never been set before
+    ap.set_foo(23, false)
+    assert_equal 23, ap.foo
+
+    # Try again, it should not be overwritten
+    ap.set_foo(13, false)
+    assert_equal 23, ap.foo
+
+    # Now overwrite it
+    ap.set_foo(13, true)
+    assert_equal 13, ap.foo
+  end
+end
+
+class AttributeModifyTest < Test::Unit::TestCase
+  class Incrementer
+    include LiveResource::Resource
+
+    resource_class :incrementer
+    resource_name :object_id
+
+    remote_accessor :value1, :value2
+
+    def initialize(value1, value2)
+      self.value1 = value1
+      self.value2 = value2
+    end
+
+    def increment(*values)
+      remote_attribute_modify(*values) do |a, v|
+        v + 1
+      end
+    end
+
+    def increment_with_interference
+      modified = false
+      remote_attribute_modify(:value1, :value2) do |a, v|
+        # modify the value from a different redis the
+        # first time through
+        unless modified
+          self.redis.clone.attribute_write(a, 10, {})
+          modified = true
+        end
+        v + 1
+      end
+    end
+  end
+
+  def setup
+    Redis.new.flushall
+
+    LiveResource::RedisClient.logger.level = Logger::INFO
+
+    Incrementer.new(1, 1)
+  end
+
+  def teardown
+    LiveResource::stop
+  end
+
+  def test_modify_without_interference
+    i = LiveResource::any(:incrementer)
+
+    assert_equal 1, i.value1
+
+    i.increment(:value1)
+
+    assert_equal 2, i.value1
+  end
+
+  def test_multi_modify_without_interference
+    i = LiveResource::any(:incrementer)
+
+    assert_equal 1, i.value1
+    assert_equal 1, i.value2
+
+    i.increment(:value1, :value2)
+
+    assert_equal 2, i.value1
+    assert_equal 2, i.value2
+  end
+
+  def test_modify_with_interference
+    i = LiveResource::any(:incrementer)
+
+    assert_equal 1, i.value1
+    assert_equal 1, i.value2
+
+    i.increment_with_interference
+
+    # Because of the interference, we should now be at 10
+    # for value1 but still only be at 2 for value2
+    assert_equal 11, i.value1
+    assert_equal 2, i.value2
+  end
+
+  def test_modify_invalid_attributes
+    i = LiveResource::any(:incrementer)
+
+    # Just a single invalid attr
+    assert_raise(ArgumentError) do
+      i.increment(:value3)
+    end
+
+    # Now two
+    assert_raise(ArgumentError) do
+      i.increment(:value3, :value4)
+    end
+
+    # Now mix with a valid attr
+    assert_raise(ArgumentError) do
+      i.increment(:value1, :value3)
+    end
+  end
+end