bridge-ruby 0.2.0

data/lib/util.rb

@@ -0,0 +1,101 @@
+require 'json'
+require 'logger'
+
+
+
+module Bridge
+  module Util #:nodoc: all
+    
+    @log = Logger.new(STDOUT)
+    
+    def self.generate_guid
+      chars = (('a'..'z').to_a + (0..9).to_a)
+      (0...12).map{ chars[rand(26)] }.join
+    end
+   
+    def self.stringify obj
+      JSON::generate obj
+    end
+   
+    def self.parse str
+      JSON::parse str
+    end 
+   
+    def self.info msg
+      @log.info msg
+    end
+    
+    def self.warn msg
+      @log.warn msg
+    end
+
+    def self.error msg
+      @log.error msg
+    end
+   
+    def self.set_log_level level
+      if level > 2
+        @log.level = Logger::INFO
+      elsif level == 2
+        @log.level = Logger::WARN
+      elsif level == 1
+        @log.level = Logger::ERROR
+      else
+        @log.level = Logger::FATAL
+      end
+    end
+   
+    def self.ref_callback ref
+      CallbackReference.new ref do |*args, &blk|
+        args << blk if blk
+        self.call *args
+      end
+    end
+    
+    def self.find_ops obj
+      if obj.is_a? Module
+        return obj.methods false
+      else
+        return obj.class.instance_methods false
+      end
+    end
+    
+    class CallbackReference < Proc
+      def initialize ref
+        @ref = ref
+      end
+
+      def callback *args, &blk
+        args << blk if blk
+        @ref.callback *args 
+      end
+
+      def call *args, &blk
+        args << blk if blk
+        @ref.callback *args
+      end
+
+      def method atom
+        if atom.to_s == 'callback'
+          self
+        else
+          Class.method atom
+        end
+      end
+
+      def methods bool
+        [:callback]
+      end
+
+      def to_dict op = nil
+        @ref.to_dict op
+      end
+      
+      def respond_to? atom
+        atom == :callback || atom == :to_dict || Class.respond_to?(atom)
+      end
+      
+    end
+    
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Bridge
+  VERSION = "0.2.0"
+end

data/rakelib/package.rake

@@ -0,0 +1,4 @@
+require 'rubygems/package_task'
+
+Gem::PackageTask.new(GEMSPEC) do |pkg|
+end

data/rakelib/test.rake

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "tests"
+  t.libs << "lib"
+  t.pattern = 'tests/**/test_*.rb'
+  t.warning = true
+end

data/test/regression/reconnect.rb

@@ -0,0 +1,48 @@
+require_relative '../../lib/bridge'
+require_relative './test'
+
+description = 'Reconnects';
+failureMessage = 'This implementation of the Bridge API does not support reconnects.';
+
+=begin
+Passing this test means the following:
+
+We can connect, reconnects (seem to) work. buffering between reconnects
+works, services are preserved between these reconnects (i.e. should happen
+in < 5s), and client ID is preserved.
+=end
+
+EM::run do
+  test = Test.new(failureMessage, 1, 4)
+
+  class T
+    def initialize(test, id)
+      @id = id
+      @test = test
+      @test.advance 1
+    end
+
+    def cb(id)
+      if id != @id
+        @test.fail "ID not preserved."
+      end
+      @test.advance 3
+      @test.close
+    end
+  end
+
+  bridge = Bridge::Bridge.new({:api_key => 'abcdefgh'}).connect {
+    test.advance 0
+  }
+
+  bridge.ready {
+    svc = T.new(test, bridge.connection.client_id)
+    bridge.publish_service('test_reconn', svc) {
+      test.advance 2
+      bridge.connection.sock.close_connection
+      EM::Timer.new(0) {
+        bridge.get_service('test_reconn') {|service| service.cb(bridge.connection.client_id)}
+      }
+    }
+  }
+end

data/test/regression/rpc.rb

@@ -0,0 +1,39 @@
+require_relative '../../lib/bridge'
+require_relative './test'
+
+description = 'Basic RPC';
+failureMessage = 'This implementation of the Bridge API is incapable of RPC.';
+
+=begin
+Passing this test means the following:
+
+We can connect (it seems), we can publish a service, the callback to
+publishService is called, and calling a method of getService works.
+
+=end
+
+EM::run do
+  test = Test.new(failureMessage, 2, 3)
+
+  bridge = Bridge::Bridge.new({:api_key => 'abcdefgh'}).connect {
+    test.advance 0
+  }
+
+  module ConsoleLogServer
+    def self.log(msg = "", test)
+      if msg == '123'
+        test.advance(2)
+      else
+        test.log('received ' + msg + ' but expected 123')
+      end
+      test.close
+    end
+  end
+
+  bridge.ready {
+    bridge.publish_service('test_consolelog', ConsoleLogServer) {
+      test.advance 1
+      bridge.get_service('test_consolelog') {|service| service.log('123', test)}
+    }
+  }
+end

data/test/regression/test.rb

@@ -0,0 +1,58 @@
+require 'eventmachine'
+
+class Test 
+  def initialize failureMessage, logLevel, stages
+    @messages = []
+    @stages = stages
+    @stage = 0
+    @failureMessage = failureMessage
+    @timer = EM::Timer.new(5) { self.fail "timeout" }
+    if !(logLevel == 0 || logLevel == 1 || logLevel == 2)
+      raise "Invalid log level #{logLevel}"
+    end
+    @logLevel = logLevel
+  end
+
+  def advance expected
+    if @stage != expected
+      self.fail "out of order: at stage #{@stage}, not #{expected}"
+    else
+      @stage += 1
+      @timer.cancel
+      @timer = EM::Timer.new(5) { self.fail "timeout" }
+      if @logLevel > 0
+        puts "Advancing to stage #{@stage}"
+      end
+    end
+  end
+
+  def close
+    if @stage != @stages
+      puts "Failure: reached stage #{@stage} of #{@stages}"
+    else
+      puts "Success; passed this test."
+    end
+    
+    Process::exit
+  end
+
+  def fail(m = failureMessage)
+    puts "============================================"
+    puts " Description: ", m
+    if @logLevel != 0
+      puts " Message stack: "
+      @messages.each {|msg| puts msg}
+    end
+    self.close
+  end
+
+  def log msg
+    if @logLevel != 0
+      @messages += msg
+      if logLevel == 2
+        puts msg
+      end
+    end
+  end
+
+end

data/test/unit/bridge_dummy.rb

@@ -0,0 +1,26 @@
+require_relative "reference_dummy.rb"
+
+class BridgeDummy
+
+  attr_accessor  :last_args, :last_dest, :stored, :options
+  
+  def initialize
+    @options = {
+      :redirector => 'http://redirector.getbridge.com',
+      :reconnect  => true,
+      :log  => 2, # 0 for no output
+    } 
+    @stored = []
+  end
+  
+  def store_object handler, ops
+    @stored << [handler, ops]
+    return ReferenceDummy.new
+  end
+  
+  def send args, destination
+    @last_args = args
+    @last_dest = destination
+  end
+
+end

data/test/unit/connection_dummy.rb

@@ -0,0 +1,21 @@
+class ConnectionDummy
+
+  attr_accessor :messages, :onopened
+  
+  def initialize
+    @messages = []
+    @onopened = false
+  end
+  
+  def onopen *args
+    @onopened = true
+  end
+  
+  def onclose *args
+  end
+  
+  def onmessage data, tcp
+    messages << data[:data]
+  end
+
+end

data/test/unit/reference_dummy.rb

@@ -0,0 +1,11 @@
+class ReferenceDummy
+
+  
+  def initialize *args
+    
+  end
+  
+  def to_dict *args
+    return "dummy"
+  end
+end

data/test/unit/tcp_dummy.rb

@@ -0,0 +1,12 @@
+class TcpDummy
+
+  attr_accessor :last_send
+  
+  def initialize *args
+    
+  end
+  
+  def send *args
+    @last_send = args
+  end
+end

data/test/unit/test.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
+end
+
+require 'test/unit'
+
+require_relative '../../lib/bridge'
+require_relative '../../lib/connection'
+require_relative '../../lib/reference'
+require_relative '../../lib/serializer'
+require_relative '../../lib/tcp'
+require_relative '../../lib/util'
+require_relative '../../lib/version'
+
+require_relative 'test_util.rb'
+require_relative 'test_serializer.rb'
+require_relative 'test_tcp.rb'
+require_relative 'test_reference.rb'
+

data/test/unit/test_reference.rb

@@ -0,0 +1,30 @@
+require "bridge"
+require_relative "bridge_dummy.rb"
+require "test/unit"
+ 
+class TestReference < Test::Unit::TestCase
+ 
+  def setup
+    
+  end
+ 
+  def teardown
+    ## Nothing really
+  end
+ 
+  
+  def test_reference
+    dummy = BridgeDummy.new
+    ref = Bridge::Reference.new dummy, ['x', 'y', 'z'], [:a, :b, :c]
+    assert_equal(['a', 'b', 'c'], ref.operations)
+    assert_equal({:ref => ['x', 'y', 'z'], :operations => ['a', 'b', 'c']}, ref.to_dict)
+    
+    blk = lambda {}
+    ref.test 1, 2, &blk
+    assert_equal([1,2,blk], dummy.last_args)
+    assert_equal(['x', 'y', 'z', 'test'], dummy.last_dest[:ref])
+    assert(!dummy.last_dest.key?(:operations))
+    
+  end
+  
+end

data/test/unit/test_serializer.rb

@@ -0,0 +1,109 @@
+require "bridge"
+require_relative "bridge_dummy.rb"
+require_relative "reference_dummy.rb"
+require "test/unit"
+ 
+class TestSerializer < Test::Unit::TestCase
+ 
+  def setup
+    
+  end
+ 
+  def teardown
+    ## Nothing really
+  end
+ 
+  
+  def test_serialize
+    dummy = BridgeDummy.new
+    test2 = Test2.new
+    test3 = Test3.new
+    test4 = lambda {}
+    obj = {
+      :a => {
+        :b => Test1
+      },
+      :c => 5,
+      :d => true,
+      :e => 'abc',
+      :f => [test2, test3],
+      :g => test2,
+      :h => test3,
+      :i => test4
+    }
+    ser = Bridge::Serializer.serialize dummy, obj
+    
+    assert(dummy.stored.include?([Test1, [:a]]))
+    assert(dummy.stored.include?([test2, [:c]]))
+    assert(dummy.stored.include?([test3, [:d, :e]]))
+    
+    found = false
+    dummy.stored.each do | x |
+      if x[1] == ['callback']
+        assert_instance_of(Bridge::Serializer::Callback, x[0])
+        found = true
+      end
+    end
+    
+    assert found
+   
+    expected_ser = {
+      :a => {
+        :b => "dummy"
+      },
+      :c => 5,
+      :d => true,
+      :e => 'abc',
+      :f => ["dummy", "dummy"],
+      :g => "dummy",
+      :h => "dummy",
+      :i => "dummy"
+    }
+   
+    assert_equal(expected_ser, ser)
+  end
+  
+  def test_unserialize
+    dummy = BridgeDummy.new
+    obj = {
+      :a => {'ref' => ['x','x','x'], 'operations' => ['a','b']},
+      :b => {
+        :i => {'ref' => ['z','z','z'], 'operations' => ['callback']}
+      },
+      :c => 5,
+      :d => true,
+      :e => 'abc',
+      :f => [1, {'ref' => ['y','y','y'], 'operations' => ['c','d']}],
+      :g => 2,
+      :h => 'foo'
+    }
+    
+    unser = Bridge::Serializer.unserialize dummy, obj
+    
+    assert_instance_of(Bridge::Reference, unser[:a])
+    assert_instance_of(Bridge::Reference, unser[:f][1])
+    assert_instance_of(Bridge::Util::CallbackReference, unser[:b][:i])
+    
+    
+  end
+  
+  module Test1
+    def self.a
+    end
+    def b
+    end
+  end
+  
+  class Test2
+    def c
+    end
+  end
+  
+  class Test3 < Test2
+    def d
+    end
+    def e
+    end
+  end
+  
+end