smartfox_jruby 0.1 → 0.2.3

data/README.md

@@ -0,0 +1,78 @@
+# SmartFox Server client library for JRuby (extension requests testing).
+
+This is a small library helping you to interact with a SmartFox server.
+It's main purpose is to test the backend extension using the requests.
+It requires JRuby and some jar-dependencies in a classpath.
+
+## What it gives
+
+You can easily connect and interact with a SmartFox server to test your server extension requests
+
+```ruby
+adapter = SmartfoxJruby::SfsAdapter.new
+adapter.login_as("user", "password")
+adapter.connect!(
+    :host => "localhost",
+    :port => 9933,
+    :zone => "test-zone"
+)
+
+adapter.process! {
+  # create extension request
+  request(:GetProducts, :productType => :ITEM).expect(:GetProductsOK) { |data|
+    puts "Whoa! I've got the following products: #{data.to_json}"
+
+    request(:BuyProduct, {:productId => data[:data].first[:id]},
+                    :serialize_opts => {:productId_type => :long}).
+      expect(:BuyProductOK) { |data|
+          puts "Whoa! I've bought product! #{data.to_json}"
+      }
+  }
+}
+adapter.disconnect!
+
+```
+
+## How to install
+
+This library uses [Doubleshot]() to process the dependencies. So you can add it as a reference by creating the
+Doubleshot
+ file on project root level:
+
+```ruby
+# encoding: utf-8
+Doubleshot.new do |config|
+
+  config.project = "myproject"
+  config.version = "0.1"
+
+  config.gem 'smartfox_jruby'
+
+  config.gemspec do |spec|
+    spec.summary = "Test Smartfox library"
+    spec.description = "TODO"
+
+    spec.homepage = "http://mysite.info"
+    spec.author = "me"
+    spec.email = "me@mail.com"
+    spec.license = "Apache 2.0"
+  end
+
+end
+
+
+```
+
+Copyright (c) 2013 smecsia
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/lib/smartfox_jruby.rb

@@ -1,14 +1,15 @@
 require 'rubygems'
 require 'ostruct'
 require 'pathname'
-Dir[Pathname.new(File.dirname(File.expand_path(__FILE__))).join("#{File.basename(__FILE__)}").join("*.rb")].each { |f| require f }
 
 ####################################################
 # Main module
 module SmartfoxJruby
-  # configurable constants
-  VERSION = "0.1"
-
-
+  MYDIR = Pathname.new(File.dirname(File.expand_path(__FILE__)))
+  autoload :SfsRunner, MYDIR.join('smartfox_jruby/sfs_runner')
+  autoload :SfsAdapter, MYDIR.join('smartfox_jruby/sfs_adapter')
+  autoload :SfsWorker, MYDIR.join('smartfox_jruby/sfs_worker')
+  autoload :SFSUtil, MYDIR.join('smartfox_jruby/common')
+  VERSION = "0.2.3"
 end
 

data/lib/smartfox_jruby/common.rb

@@ -20,35 +20,38 @@ module ISFSObject
   end
 end
 
-module SmartfoxJruby::SFSUtil
-  class << self
-    def boxing(v, type)
-      case type
-        when :long
-          java.lang.Long.valueOf(v)
-        when :float
-          java.lang.Float.valueOf(v)
-        when :double
-          java.lang.Double.valueOf(v)
-        when :int
-          java.lang.Integer.valueOf(v)
-        when :boolean
-          java.lang.Boolean.valueOf(v)
-        else
-          v
+module SmartfoxJruby
+  module SFSUtil
+    class << self
+      def boxing(v, type)
+        case type
+          when :long
+            java.lang.Long.valueOf(v)
+          when :float
+            java.lang.Float.valueOf(v)
+          when :double
+            java.lang.Double.valueOf(v)
+          when :int
+            java.lang.Integer.valueOf(v)
+          when :boolean
+            java.lang.Boolean.valueOf(v)
+          else
+            v
+        end
       end
-    end
 
-    def to_java_list(value, type)
-      list = java.util.ArrayList.new
-      value.to_java(type).each do |v|
-        list.add(boxing(v, type))
+      def to_java_list(value, type)
+        list = java.util.ArrayList.new
+        value.to_java(type).each do |v|
+          list.add(boxing(v, type))
+        end
+        list
       end
-      list
     end
   end
 end
 
+
 def SFSObject.from_hash(hash, opts = {})
   res = SFSObject.new
   opts ||= {}

data/lib/smartfox_jruby/sfs_adapter.rb

@@ -1,172 +1,174 @@
 require File.expand_path(File.dirname(__FILE__) + '/sfs_worker')
 
-class SmartfoxJruby::SfsAdapter
-  include IEventListener
-  attr_reader :opts
-  attr_reader :smart_fox
-  attr_reader :worker
-  attr_reader :username
-  DEBUG = false
-
-  def initialize(opts = {})
-    @opts = opts
-    debug "initializing sfs adapter..."
-    @smart_fox = SmartFox.new(false)
-    @connected = false
-    @worker = opts[:worker]
-    @login_as = {}
-    @opts[:timeout] ||= 20
-    @opts[:logger] ||= Logger.new(STDOUT)
-    SFSEvent.constants.each do |evt|
-      evt_value = SFSEvent.const_get(evt)
-      debug "Registering event adapter to self for event '#{evt}' --> '#{evt_value}'..."
-      smart_fox.add_event_listener(evt_value, self)
+module SmartfoxJruby
+
+  class SfsAdapter
+    include IEventListener
+    attr_reader :opts
+    attr_reader :smart_fox
+    attr_reader :worker
+    attr_reader :username
+    DEBUG = false
+
+    def initialize(opts = {})
+      @opts = opts
+      @smart_fox = SmartFox.new(false)
+      @connected = false
+      @worker = opts[:worker]
+      @login_as = opts[:login_as] || {}
+      @opts[:timeout] ||= 20
+      @opts[:logger] ||= Logger.new(STDOUT)
+      SFSEvent.constants.each do |evt|
+        evt_value = SFSEvent.const_get(evt)
+        debug "Registering event adapter to self for event '#{evt}' --> '#{evt_value}'..."
+        smart_fox.add_event_listener(evt_value, self)
+      end
+      debug "initializing sfs adapter..."
     end
-  end
 
-  def connect!(opt = {})
-    opts.reverse_merge!(opt)
-    raise "host and port are required to connect SfsAdapter!" if opts[:host].blank? || opts[:port].blank?
-    debug "connecting to smartfox at #{opts[:host]}:#{opts[:port]} ..."
-    smart_fox.connect(opts[:host], opts[:port])
-  end
+    def connect!(opt = {})
+      opts.reverse_merge!(opt)
+      raise "host and port are required to connect SfsAdapter!" if opts[:host].blank? || opts[:port].blank?
+      debug "connecting to smartfox at #{opts[:host]}:#{opts[:port]} ..."
+      smart_fox.connect(opts[:host], opts[:port])
+    end
 
-  def dispatch(event)
-    debug "got event #{event.type}: #{event}"
-    callback = "on_#{event.type.try(:underscore)}_event"
-    if respond_to?(callback, true)
-      send(callback, event)
-    else
-      debug "Unknown event caught #{event.type} (No method '#{callback}' in #{self})"
+    def dispatch(event)
+      debug "got event #{event.type}: #{event}"
+      callback = "on_#{event.type.try(:underscore)}_event"
+      if respond_to?(callback, true)
+        send(callback, event)
+      else
+        debug "Unknown event caught #{event.type} (No method '#{callback}' in #{self})"
+      end
     end
-  end
 
-  def disconnect!
-    smart_fox.disconnect
-  end
+    def disconnect!
+      smart_fox.disconnect
+    end
 
-  def process!(wrk = nil, &block)
-    wait_with_timeout(@opts[:timeout]) { connected? }
-    @worker = wrk || opts[:worker]
-    if block_given? && connected?
-      instance_eval(&block)
-    else
-      raise "Worker is null!" if @worker.blank?
-      raise "Not connected!" unless connected?
+    def process!(wrk = nil, &block)
+      wait_with_timeout(@opts[:timeout]) { connected? }
+      @worker = wrk || opts[:worker]
+      if block_given? && connected?
+        instance_eval(&block)
+      else
+        raise "Worker is null!" if @worker.blank?
+        raise "Not connected!" unless connected?
+      end
+      worker.perform!
     end
-    worker.perform!
-  end
 
-  def connected?
-    @connected
-  end
+    def connected?
+      @connected
+    end
 
-  def on_connect(&block)
-    @on_connect ||= []
-    @on_connect << block if block_given?
-  end
+    def on_connect(&block)
+      @on_connect ||= []
+      @on_connect << block if block_given?
+    end
 
-  def on_login(&block)
-    @on_login ||= []
-    @on_login << block if block_given?
-  end
+    def on_login(&block)
+      @on_login ||= []
+      @on_login << block if block_given?
+    end
 
-  def login_as(username, password, params = {})
-    params = input_params.to_sfsobject if params.is_a?(Hash)
-    @login_as ||= {:username => username, :password => password, :params => params}
-  end
+    def login_as(username, password, params = {})
+      params = params.to_sfsobject if params.is_a?(Hash)
+      @login_as = {:username => username, :password => password, :params => params}
+    end
 
-  private
+    private
 
-  ###############
-  ### HELPERS ###
+    ###############
+    ### HELPERS ###
 
-  def request(*args)
-    worker.request(*args)
-  end
+    def request(*args)
+      worker.request(*args)
+    end
 
-  def worker(opts = {})
-    @worker ||= SfsWorker::Worker.new(@smart_fox, opts)
-    @worker
-  end
+    def worker(opts = {})
+      @worker ||= SfsWorker::Worker.new(@smart_fox, opts)
+      @worker
+    end
 
-  def sfs_send(req)
-    smart_fox.send(req)
-  end
+    def sfs_send(req)
+      smart_fox.send(req)
+    end
 
-  #########################
-  ### EVENTS PROCESSORS ###
+    #########################
+    ### EVENTS PROCESSORS ###
 
-  def on_extension_response_event(event)
-    debug "extension_response #{event.arguments.get("cmd")}"
-    @worker.response(event.arguments.get("cmd"), event.arguments.get("params").try(:to_hash) || {}) unless @worker.blank?
-  end
+    def on_extension_response_event(event)
+      debug "extension_response #{event.arguments.get("cmd")}"
+      @worker.response(event.arguments.get("cmd"), event.arguments.get("params").try(:to_hash) || {}) unless @worker.blank?
+    end
 
-  def on_connection_event(event)
-    debug "on_connection #{event}"
-    @on_connect.each { |block|
-      block.call(event) if block.is_a?(Proc)
-    } unless @on_connect.blank?
-    sfs_send(LoginRequest.new(@login_as[:username], @login_as[:password], opts[:zone],
-                              (@login_as[:params] || {}).to_sfsobject));
-  end
+    def on_connection_event(event)
+      debug "on_connection #{event}"
+      @on_connect.each { |block|
+        block.call(event) if block.is_a?(Proc)
+      } unless @on_connect.blank?
+      sfs_send(LoginRequest.new(@login_as[:username], @login_as[:password], opts[:zone],
+                                (@login_as[:params] || {}.to_sfsobject)));
+    end
 
-  def on_login_event(event)
-    args = event.arguments.get("data").to_hash
-    user = event.arguments.get("user")
-    debug("on_login, args=#{args.to_json}")
-    unless user.blank?
-      info "connected as #{user.name}"
-      @username = user.name
-      @connected = true
-      @on_login.each { |block|
-        block.call(@username) if block.is_a?(Proc)
-      } unless @on_login.blank?
-    else
-      raise "login error '#{args[Aimy::Param.ERROR_MESSAGE]}'"
+    def on_login_event(event)
+      args = event.arguments.get("data").to_hash
+      user = event.arguments.get("user")
+      debug("on_login, args=#{args.to_json}")
+      unless user.blank?
+        info "connected as #{user.name}"
+        @username = user.name
+        @connected = true
+        @on_login.each { |block|
+          block.call(@username) if block.is_a?(Proc)
+        } unless @on_login.blank?
+      else
+        raise "login error '#{args[Aimy::Param.ERROR_MESSAGE]}'"
+      end
     end
-  end
 
-  def on_login_error_event(event)
-    error("error while logging-in: #{event.arguments}")
-  end
+    def on_login_error_event(event)
+      error("error while logging-in: #{event.arguments}")
+    end
 
-  def on_connection_lost_event(event)
-    # nothing to do
-  end
+    def on_connection_lost_event(event)
+      # nothing to do
+    end
 
-  def on_handshake_event(event)
-    # nothing to do
-  end
+    def on_handshake_event(event)
+      # nothing to do
+    end
 
 
-  #######################
-  ### SERVICE HELPERS ###
+    #######################
+    ### SERVICE HELPERS ###
 
-  def logger
-    opts[:logger]
-  end
+    def logger
+      opts[:logger]
+    end
 
-  def debug_enabled?
-    opts[:debug] || DEBUG
-  end
+    def debug_enabled?
+      opts[:debug] || DEBUG
+    end
 
-  def debug(msg)
-    logger.debug "#{msg}" if debug_enabled?
-  end
+    def debug(msg)
+      logger.debug "#{msg}" if debug_enabled?
+    end
 
-  def info(msg)
-    logger.info "#{msg}"
-  end
+    def info(msg)
+      logger.info "#{msg}"
+    end
 
-  def log(msg)
-    logger.info "#{msg}"
-  end
+    def log(msg)
+      logger.info "#{msg}"
+    end
 
-  def error(msg)
-    logger.error "#{msg}"
-  end
+    def error(msg)
+      logger.error "#{msg}"
+    end
 
+  end
 
 end
-