skein 0.3.0

data/test/helper.rb

@@ -0,0 +1,42 @@
+require 'test/unit'
+
+$LOAD_PATH << File.expand_path('../lib', File.dirname(__FILE__))
+
+require 'skein'
+
+# Simulate Rails 'test' environment
+ENV['RAILS_ENV'] = 'test'
+
+# Ensure tests are run from the root of the project so that configuration
+# files can be found and loaded.
+Dir.chdir(File.expand_path('../', File.dirname(__FILE__)))
+
+class Test::Unit::TestCase
+  def assert_mapping(map)
+    result_map = map.each_with_object({ }) do |(k,v), h|
+      h[k] = yield(k)
+    end
+    
+    assert_equal map, result_map do
+      result_map.each_with_object([ ]) do |(k,v), a|
+        unless (v == map[k])
+          a << k
+        end
+      end.map do |s|
+        "Input: #{s.inspect}\n  Expected: #{map[s].inspect}\n  Result:   #{result_map[s].inspect}\n"
+      end.join
+    end
+  end
+
+  def assert_no_threads(message = nil)
+    threads = Thread.list.length
+
+    yield
+
+    assert_equal threads, Thread.list.length, message
+  end
+
+  def data_path(name)
+    File.expand_path(File.join('data', name), File.dirname(__FILE__))
+  end
+end

data/test/script/em_example

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+gem 'eventmachine'
+require 'eventmachine'
+
+$LOAD_PATH << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'skein'
+
+# == Support Classes ========================================================
+
+class EchoWorker < Skein::Client::Worker
+  def echo(*args)
+    yield(*args)
+  end
+
+  def async?
+    true
+  end
+end
+
+# == Main ===================================================================
+
+EventMachine.run do
+  EchoWorker.new('test_echo')
+end

data/test/unit/test_skein_client.rb

@@ -0,0 +1,18 @@
+require_relative '../helper'
+
+class TestSkeinClient < Test::Unit::TestCase
+  def test_default
+    client = nil
+
+    assert_no_threads do
+      client = Skein::Client.new
+
+      assert client.context
+
+      client.close
+    end
+
+  # ensure
+  #   client and client.close
+  end
+end

data/test/unit/test_skein_client_publisher.rb

@@ -0,0 +1,10 @@
+require_relative '../helper'
+
+class TestSkeinPublisher < Test::Unit::TestCase
+  def test_defaults
+    publisher = Skein::Client::Publisher.new('test_name')
+
+  ensure
+    publisher and publisher.close
+  end
+end

data/test/unit/test_skein_client_subscriber.rb

@@ -0,0 +1,41 @@
+require_relative '../helper'
+
+class TestSkeinClientSubscriber < Test::Unit::TestCase
+  def test_cycle
+    client = Skein::Client.new
+
+    publisher = client.publisher('test')
+
+    received = nil
+
+    subscriber = client.subscriber('test', '*.*') 
+    subscribing = false
+
+    thread = Thread.new do
+      Thread.abort_on_exception = true
+
+      subscribing = true
+
+      subscriber.listen do |payload|
+        received = payload
+
+        Thread.exit
+      end
+    end
+
+    while (!subscribing)
+      # Spin-lock to wait for the subscriber to come online
+    end
+
+    publisher.publish!({ data: true }, 'test.notification')
+
+    thread.join
+
+    assert_equal({ "data" => true }, received)
+
+  ensure
+    publisher and publisher.close
+    subscriber and subscriber.close
+    client and client.close
+  end
+end

data/test/unit/test_skein_client_worker.rb

@@ -0,0 +1,61 @@
+require_relative '../helper'
+
+class TestSkeinClientWorker < Test::Unit::TestCase
+  class ErrorGenerator < Skein::Client::Worker
+    class CustomError < RuntimeError
+    end
+
+    def raises_error
+      raise CustomError, 'Example error!'
+    end
+  end
+
+  def test_example
+    worker = Skein::Client::Worker.new('test_rpc')
+    handler = Skein::Handler.for(worker)
+
+    message = {
+      method: 'ident',
+      params: [ ],
+      id: '43d8352c-4907-4c32-9c81-fc34e91a3884'
+    }
+
+    handler.handle(JSON.dump(message)) do |response_json, error|
+      response = JSON.load(response_json)
+
+      expected = {
+        'result' => worker.ident,
+        'error' => nil,
+        'id' => message[:id]
+      }
+
+      assert_equal(expected, response)
+    end
+
+  ensure
+    worker and worker.close
+  end
+
+  def test_throws_exception
+    worker = ErrorGenerator.new('test_error')
+    handler = Skein::Handler.for(worker)
+
+    message = {
+      method: 'raises_error',
+      id: '29fe8a40-fccf-43c6-ba48-818598c66e6f'
+    }
+
+    handler.handle(JSON.dump(message)) do |response_json, error|
+      expected = {
+        'result' => nil,
+        'error' => '[TestSkeinClientWorker::ErrorGenerator::CustomError] Example error!',
+        'id' => message[:id]
+      }
+
+      assert_equal(expected.to_json, response_json)
+    end
+
+  ensure
+    worker and worker.close
+  end
+end

data/test/unit/test_skein_config.rb

@@ -0,0 +1,33 @@
+require_relative '../helper'
+
+class TestSkeinConfig < Test::Unit::TestCase
+  def test_env
+    assert_equal('test', Skein::Config.env)
+  end
+
+  def test_default_state
+    config = Skein::Config.new(false)
+
+    assert config
+
+    assert_equal('127.0.0.1', config.host)
+    assert_equal(5672, config.port)
+    assert_equal('guest', config.username)
+    assert_equal('guest', config.password)
+    assert_equal(nil, config.namespace)
+  end
+
+  def test_with_config_path
+    config = Skein::Config.new(data_path('sample_config.yml'))
+
+    assert_equal('test.host', config.host)
+    assert_equal(5670, config.port)
+    assert_equal('test_user', config.username)
+    assert_equal('test_password', config.password)
+    assert_equal('test', config.namespace)
+  end
+
+  def test_config_exists
+    assert_equal(true, Skein::Config.exist?)
+  end
+end

data/test/unit/test_skein_context.rb

@@ -0,0 +1,44 @@
+require_relative '../helper'
+
+class TestSkeinContext < Test::Unit::TestCase
+  def test_default
+    context = Skein::Context.default
+
+    assert(context)
+
+    assert_equal(Skein::Support.hostname, context.hostname)
+    assert_equal(Skein::Support.process_name, context.process_name)
+    assert_equal(Skein::Support.process_id, context.process_id)
+  end
+
+  def test_defaults
+    context = Skein::Context.new
+
+    assert_equal(Skein::Support.hostname, context.hostname)
+    assert_equal(Skein::Support.process_name, context.process_name)
+    assert_equal(Skein::Support.process_id, context.process_id)
+  end
+
+  def test_override
+    context = Skein::Context.new(
+      hostname: 'sample.host',
+      process_name: 'test_process',
+      process_id: 20301
+    )
+
+    assert_equal('sample.host', context.hostname)
+    assert_equal('test_process', context.process_name)
+    assert_equal(20301, context.process_id)
+  end
+
+  def test_generate_ident
+    context = Skein::Context.new
+
+    ident = context.ident(self)
+
+    assert(ident)
+
+    assert_not_equal(ident, context.ident(context))
+    assert_equal(ident, context.ident(self))
+  end
+end

data/test/unit/test_skein_rabbitmq.rb

@@ -0,0 +1,14 @@
+require_relative '../helper'
+
+class TestSkeinRabbitMQ < Test::Unit::TestCase
+  def test_can_connect
+    rmq = Skein::RabbitMQ.connect
+
+    assert rmq
+
+    assert rmq.respond_to?(:create_channel)
+
+  ensure
+    rmq and rmq.close
+  end
+end

data/test/unit/test_skein_reporter.rb

@@ -0,0 +1,4 @@
+require_relative '../helper'
+
+class TestSkeinReporter < Test::Unit::TestCase
+end

data/test/unit/test_skein_rpc_error.rb

@@ -0,0 +1,10 @@
+require_relative '../helper'
+
+class TestSkeinRPCError < Test::Unit::TestCase
+  def test_default
+    error = Skein::RPC::Error.new
+
+    assert_equal nil, error.id
+    assert_equal nil, error.error
+  end
+end

data/test/unit/test_skein_rpc_request.rb

@@ -0,0 +1,93 @@
+require_relative '../helper'
+
+class TestSkeinRPCRequest < Test::Unit::TestCase
+  def test_default
+    request = Skein::RPC::Request.new
+
+    assert request.id
+    assert request.id.match(/\A\h{8}\-\h{4}\-\h{4}\-\h{4}\-\h{12}\z/)
+
+    assert_equal nil, request.method
+    assert_equal nil, request.params
+  end
+
+  def test_with_invalid_method_name
+    request = Skein::RPC::Request.new(
+      method: 'invalid name',
+      id: 'aa8304bd-5c4a-4b77-a1bf-87f90d59b3af'
+    )
+
+  rescue Skein::RPC::InvalidMethod => e
+    assert e
+
+    assert e.request.is_a?(Skein::RPC::Request)
+    assert_equal 'aa8304bd-5c4a-4b77-a1bf-87f90d59b3af', e.to_error.id
+  else
+    fail
+  end
+
+  def test_with_no_method_name
+    request = Skein::RPC::Request.new(
+      method: nil,
+      id: 'aa8304bd-5c4a-4b77-a1bf-87f90d59b3af'
+    )
+  end
+
+  def test_with_single_param
+    request = Skein::RPC::Request.new(
+      method: 'single_param',
+      params: 'single'
+    )
+
+    assert_equal %w[ single ], request.params
+  end
+
+  def test_from_json_string
+    raw = {
+      method: 'test_method',
+      params: nil,
+      id: 'e0b6cffa-8040-4c44-bc11-7fc3d8f4662c'
+    }
+
+    json = JSON.dump(raw)
+
+    request = Skein::RPC::Request.new(json)
+
+    assert_equal 'test_method', request.method
+    assert_equal nil, request.params
+    assert_equal 'e0b6cffa-8040-4c44-bc11-7fc3d8f4662c', request.id
+
+    assert_equal raw, request.to_h
+  end
+
+  def test_from_hash
+    raw = {
+      method: 'test_method',
+      params: nil,
+      id: 'e0b6cffa-8040-4c44-bc11-7fc3d8f4662c'
+    }
+
+    request = Skein::RPC::Request.new(raw)
+
+    assert_equal 'test_method', request.method
+    assert_equal nil, request.params
+    assert_equal 'e0b6cffa-8040-4c44-bc11-7fc3d8f4662c', request.id
+
+    assert_equal raw, request.to_h
+  end
+
+  def test_to_response_result
+    request = Skein::RPC::Request.new(
+      method: 'test_method',
+      params: 'test',
+      id: 'd8b625f1-5e0b-4bcf-bf6e-569e9edc634d'
+    )
+
+    response = request.response(
+      result: %w[ result ]
+    )
+
+    assert_equal request.id, response.id
+    assert_equal %w[ result ], response.result
+  end
+end

data/test/unit/test_skein_support.rb

@@ -0,0 +1,95 @@
+require_relative '../helper'
+
+class TestSkeinSupport < Test::Unit::TestCase
+  def test_symbolize_keys_simple_hash
+    hash = {
+      'test' => 'test_value',
+      true => 'true_value',
+      2 => 'two'
+    }
+
+    expected = {
+      test: 'test_value',
+      true: 'true_value',
+      '2': 'two'
+    }
+
+    assert_equal(expected, Skein::Support.symbolize_keys(hash))
+  end
+
+  def test_symbolize_keys_on_array
+    array = [
+      {
+        'test' => :value,
+        'nested' => {
+          'hash' => true
+        }
+      },
+      {
+        'second' => :hash
+      }
+    ]
+
+    expected = [
+      {
+        test: :value,
+        nested: {
+          hash: true
+        }
+      },
+      {
+        second: :hash
+      }
+    ]
+
+    assert_equal(expected, Skein::Support.symbolize_keys(array))
+  end
+
+  def test_symbolize_keys_on_non_hashes
+    assert_mapping(
+      1 => 1,
+      true => true,
+      nil => nil,
+      'test' => 'test',
+      :symbol => :symbol
+    ) do |value|
+      Skein::Support.symbolize_keys(value)
+    end
+  end
+
+  def test_hostname
+    hostname = Skein::Support.hostname
+
+    assert_equal(String, hostname.class)
+    assert(hostname.length > 0)
+  end
+
+  def test_process_name
+    process_name = Skein::Support.process_name
+
+    assert(process_name)
+
+    assert(%w[ test_skein_support rake_test_loader ].include?(process_name))
+  end
+
+  def test_pid
+    process_id = Skein::Support.process_id
+
+    assert(process_id)
+    assert(process_id.is_a?(Integer))
+  end
+
+  def test_arrayify
+    assert_mapping(
+      [ :test ] => [ :test ],
+      :test => [ :test ],
+      true => [ true ],
+      0 => [ 0 ],
+      [ 0 ] => [ 0 ],
+      [ nil ] => [ nil ],
+      nil => nil
+    ) do |value|
+      Skein::Support.arrayify(value)
+    end
+  end
+end