liveresource 2.0.0

data/old/state_publisher_test.rb

@@ -0,0 +1,139 @@
+require 'live_resource'
+require 'test/unit'
+require 'thread'
+
+Thread.abort_on_exception = true
+
+class StatePublisherTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+    @trace = false
+  end
+
+  def trace(s)
+    puts("- #{s}") if @trace
+  end
+  
+  def test_get_state
+    resource = LiveResource.new('test_get_state')
+    resource.set :foo
+    assert_equal :foo, resource.get
+  end
+  
+  def subscribe(name, states)
+    thread = Thread.new do
+      trace "Subscriber started"
+
+      resource = LiveResource.new(name)
+
+      resource.subscribe do |new_state|
+        trace "Subscriber saw change to #{new_state}"
+        states << new_state
+        
+        resource.unsubscribe if (new_state == :dead)
+      end
+      
+      trace "Subscriber done"
+    end
+    
+    sleep 0.1 # Give subscriber chance to start
+    thread
+  end
+  
+  def test_subscribe_to_state
+    resource = LiveResource.new('test_subscribe_to_state')
+    states = Queue.new
+
+    resource.set :ok  # Starting state
+
+    subscriber = subscribe('test_subscribe_to_state', states)
+    
+    trace "Setting state (1)"
+    resource.set :warning
+    
+    Thread.pass while (states.length < 1)
+
+    trace "Setting state (2)"
+    resource.set :dead
+
+    subscriber.join
+
+    assert_equal :warning, states.pop
+    assert_equal :dead, states.pop    
+  end
+  
+  def test_unsubscribe_with_no_subscription
+    resource = LiveResource.new('test_unsubscribe_with_no_subscription')
+    
+    assert_raise(RuntimeError) do
+      resource.unsubscribe
+    end
+  end
+  
+  def test_subscribe_with_no_initial_state
+    resource = LiveResource.new('test_subscribe_with_no_initial_state')    
+    states = Queue.new
+    
+    subscriber = subscribe('test_subscribe_to_state', states)
+    
+    resource.set :dead
+    subscriber.join
+    
+    assert_equal 0, states.length
+  end
+  
+  def test_publish_eliminates_duplicates
+    resource = LiveResource.new('test_publish_eliminates_duplicates')
+    states = Queue.new
+    subscriber = subscribe('test_publish_eliminates_duplicates', states)
+
+    resource.set :foo
+    resource.set :foo
+    resource.set :foo
+
+    # Resource should only publish one instance of :foo
+    assert_equal 1, states.length
+    assert_equal :foo, states.pop
+
+    resource.set :dead
+    subscriber.join    
+  end
+  
+  def test_multiple_subscribers
+    resource = LiveResource.new('test_multiple_subscribers')
+    num_subscribers = 5
+    num_messages = 100
+    states = []
+    subscribers = []
+    
+    num_subscribers.times do
+      state_queue = Queue.new
+      states << state_queue
+      subscribers << subscribe('test_multiple_subscribers', state_queue)
+    end
+    
+    (num_messages - 1).times do |i|
+      resource.set "state #{i + 1}"
+      Thread.pass if (i % 4) # Pass once in a while
+    end
+
+    # Even though we have multiple subscribers, there should only 
+    # be one channel in Redis.
+    assert_equal 1, Redis.new.info["pubsub_channels"].to_i
+    
+    resource.set :dead
+    
+    sleep 0.1
+    
+    num_subscribers.times do |i|
+      subscribers[i].join
+    end
+    
+    assert_equal num_messages, states[0].length
+    assert_equal num_messages, states[1].length
+    assert_equal num_messages, states[num_subscribers - 1].length
+    
+    # Should have no junk left over in Redis
+    assert_equal 0, Redis.new.info["pubsub_channels"].to_i
+  end
+end

data/old/test/attribute_modify_test.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Incrementer
+  include LiveResource::Attribute
+
+  remote_accessor :value
+
+  def initialize(initial_value)
+    self.namespace = 'test'
+    self.value = initial_value
+  end
+  
+  def increment(&block)
+    remote_modify(:value) do |v|
+      # Allow someone else to mess with Redis while we're 
+      # in the modify block.
+      block.call(redis_space.clone) if block
+      
+      v + 1
+    end
+  end
+end
+
+class AttributeModifyTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+	end
+	
+	def test_modify_without_interference
+	  i = Incrementer.new(1)
+	  i.increment
+	  assert_equal 2, i.value
+  end
+
+	def test_modify_with_interference
+	  i = Incrementer.new(1)
+	  messed_with = false
+
+	  i.increment do |redis_space|
+	    # Mess with value first time around
+	    unless messed_with
+	      redis_space.attribute_set('value', 10)
+	      messed_with = true
+      end
+    end
+    
+    # Since the increment is replayed after LiveResource determines
+    # the attribute was messed with, the final value should be one
+    # increment from 10, not the original value 1.
+	  assert_equal 11, i.value
+  end
+end

data/old/test/attribute_options_test.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class TransientColorServer
+  include LiveResource::Attribute
+  
+  # Currently the only option is TTL
+  remote_writer :color, :ttl => 1
+  remote_accessor :color2, :ttl => 1
+  
+  def initialize
+    self.namespace = "colors.favorite.transient"
+  end  
+end
+
+class TransientColorClient
+  include LiveResource::Attribute
+
+  remote_reader :color, :color2
+    
+  def initialize
+    self.namespace = "colors.favorite.transient"
+  end
+end
+
+class AttributeOptionsTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+
+    @client = TransientColorClient.new
+    @server = TransientColorServer.new
+  end
+  
+  def test_accessors_defined
+    assert @server.respond_to? :color=
+    assert_equal false, @server.respond_to?(:color)
+    assert @server.respond_to? :color2
+    assert @server.respond_to? :color2=
+
+    assert @client.respond_to? :color
+    assert_equal false, @client.respond_to?(:color=)
+    assert @client.respond_to? :color2
+    assert_equal false, @client.respond_to?(:color2=)
+  end
+
+  def test_simple_read_write
+    assert_equal nil, @client.color
+    
+    @server.color = 'blue'
+    assert_equal 'blue', @client.color
+
+    sleep 2
+    assert_equal nil, @client.color
+  end
+end

data/old/test/attribute_subscriber_test.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class UserLogin
+  include LiveResource::Attribute
+  
+  remote_writer :user_logged_in
+  remote_writer :user_logged_out
+  remote_writer :sudo
+  
+  def initialize(name)
+    self.namespace = name
+  end
+  
+  def start
+    Thread.new do
+      self.user_logged_in = "Bob"
+      self.user_logged_in = "Fred"
+      self.user_logged_out = "Fred"
+
+      sleep 0.1
+
+      self.sudo = ["Bob", "rm"]
+      self.user_logged_in = "Susan"
+      self.user_logged_out = "Bob"
+      self.user_logged_out = "Susan"
+    end
+  end
+end
+
+class AuditLog
+  include LiveResource::Subscriber
+
+  remote_subscription :user_logged_in, :login
+  remote_subscription :user_logged_out, :logout
+  remote_subscription :sudo # Implies method name
+
+  def initialize(name)
+    @backing_store = StringIO.new("", "r+")
+    @audit_log = Logger.new(@backing_store)
+    self.namespace = name
+  end
+  
+  def login(user)
+    @audit_log.info "User #{user} logged in"
+  end
+  
+  def logout(user)
+    @audit_log.info "User #{user} logged out"
+  end
+  
+  def sudo(params)
+    @audit_log.info "User #{params[0]} ran #{params[1]} as superuser"
+  end
+  
+  def dump
+    @backing_store.rewind
+    @backing_store.readlines
+  end
+end
+
+class AttributeSubscriberTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+  end
+  
+  def test_attribute_publishes_to_redis
+    # Setting attribute should both send a set and publish to Redis.
+    Redis.any_instance.expects(:[]=).once
+    Redis.any_instance.expects(:publish).once
+
+    UserLogin.new("users").user_logged_in = "Bob"
+  end
+  
+  def test_subscriber_receives_events
+    login = UserLogin.new("users")
+    audit_log = AuditLog.new("users")
+    
+    audit_log.subscribe
+    login.start
+
+    sleep 0.25
+    audit_log.unsubscribe
+    
+    # This sequence should match what's in UserLogin.start
+    audit_log = audit_log.dump
+    assert_match "User Bob logged in", audit_log[0]
+    assert_match "User Fred logged in", audit_log[1]
+    assert_match "User Fred logged out", audit_log[2]
+    assert_match "User Bob ran rm as superuser", audit_log[3]
+    assert_match "User Susan logged in", audit_log[4]
+    assert_match "User Bob logged out", audit_log[5]
+    assert_match "User Susan logged out", audit_log[6]
+  end
+end

data/old/test/composite_resource_test.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class FavoriteColor
+  include LiveResource::Attribute
+
+  remote_writer :color
+  
+  def initialize
+    self.namespace = 'colors.favorite'
+  end
+end
+
+class UpcasedFavoriteColor
+  include LiveResource::Attribute
+  include LiveResource::Subscriber
+  include LiveResource::MethodProvider
+  include LiveResource::MethodSender
+  
+  remote_accessor :upcased_color
+  remote_subscription :color, :update_color
+  remote_method :foo
+  
+  def initialize
+    self.namespace = 'colors.favorite'
+  end
+  
+  def update_color(new_color)
+    self.upcased_color = new_color.upcase
+  end
+  
+  # I know this has nothing to do with colors. Sue me. -jdc
+  def foo
+    'foo'
+  end
+end
+
+class CompositeResourceTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+  end
+
+  def test_composite_resource
+    fave = FavoriteColor.new
+    upcased_fave = UpcasedFavoriteColor.new
+    upcased_fave.subscribe
+    upcased_fave.start_method_dispatcher
+    
+    fave.color = 'blue'
+    sleep(0.25) # Takes a moment to propogate
+    assert_equal 'BLUE', upcased_fave.upcased_color
+    
+    assert_equal 'foo', upcased_fave.remote_send(:foo)
+    
+    fave.color = 'green'
+    sleep(0.25) # Takes a moment to propogate
+    assert_equal 'GREEN', upcased_fave.upcased_color
+    
+    upcased_fave.unsubscribe
+    upcased_fave.stop_method_dispatcher
+  end
+end

data/old/test/method_sender_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class Sender
+  include LiveResource::MethodSender
+  
+  def initialize
+    self.namespace = 'test'
+  end
+end
+
+class MethodSenderTest < Test::Unit::TestCase
+  def setup
+    Redis.new.flushall
+  end
+  
+  def test_send_sequence
+    sender = Sender.new
+    rs = sender.redis_space.clone
+    
+    # Put method on waiting queue
+    token = sender.remote_send_async(:method, 1, 2, 3)
+    assert_not_nil token
+    assert_equal false, sender.done_with?(token)
+    assert_equal :method, rs.method_get(token, :method)
+    assert_equal [1, 2, 3], rs.method_get(token, :params)
+    
+    # Now play provider, move token from waiting to in-progress.
+    token2 = rs.method_wait
+    assert_equal token2, token
+    assert_equal false, sender.done_with?(token)
+    
+    # Set and fetch result
+    rs.result_set token, 42
+    rs.method_done token
+    assert_equal true, sender.done_with?(token)
+    assert_equal 42, sender.wait_for_done(token)
+    
+    # No crud left around in Redis
+    assert_equal 0, Redis.new.dbsize
+  end
+end