socky 0.2.1 → 0.4.0

data/spec/socky/options_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Options do
-  
-  context "class" do
-    before(:all) do
-      @default_options = Socky.options
-    end
-    after(:each) do
-      Socky.options = @default_options
-    end
-
-    context "#prepare" do
-      before(:each) do
-        Socky::Options::Parser.stub!(:parse).and_return({})
-        Socky::Options::Config.stub!(:read).and_return({})
-      end
-      it "should call parser with self option" do
-        Socky::Options::Parser.should_receive(:parse).with([:a,:b,:c])
-        Socky::Options.prepare([:a,:b,:c])
-      end
-      it "should call read_config with patch" do
-        Socky::Options::Config.should_receive(:read).with("/var/run/socky.yml", :kill => nil)
-        Socky::Options.prepare([])
-      end
-      it "should set Socky options to default hash when parse_options and read_config don't do anything" do
-        Socky::Options.prepare([])
-        Socky.options.should eql(default_options)
-      end
-      it "should value parse_options over default values" do
-        Socky::Options::Parser.stub!(:parse).and_return(:log_path => "parsed")
-        Socky::Options.prepare([])
-        Socky.options.should eql(default_options.merge(:log_path=>"parsed"))
-      end
-      it "should value read_config over default values" do
-        Socky::Options::Config.stub!(:read).and_return(:log_path => "from config")
-        Socky::Options.prepare([])
-        Socky.options.should eql(default_options.merge(:log_path=>"from config"))
-      end
-      it "should value parse_options over read_config" do
-        Socky::Options::Config.stub!(:read).and_return(:log_path => "from config")
-        Socky::Options::Parser.stub!(:parse).and_return(:log_path => "parsed")
-        Socky::Options.prepare([])
-        Socky.options.should eql(default_options.merge(:log_path=>"parsed"))
-      end
-    end
-  end
-  
-  def default_options
-    {
-      :port => 8080,
-      :log_path => nil,
-      :debug => false,
-      :deep_debug => false,
-      :secure => false,
-      :config_path => "/var/run/socky.yml"
-    }
-  end
-
-end

data/spec/socky/runner_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Runner do
-  
-  context "#class" do
-    context "#run" do
-      before(:each) do
-        @server = mock(:server, :start => nil)
-        described_class.stub!(:new).and_return(@server)
-      end
-      it "should create new instance of self" do
-        described_class.should_receive(:new).with("some args")
-        described_class.run("some args")
-      end
-      it "should call #start on new instance of self if daemonize option is false" do
-        Socky.stub(:options).and_return({:daemonize => false})
-        @server.should_receive(:start)
-        described_class.run
-      end
-      it "should call #daemonize on new instance of self if daemonize option is true" do
-        Socky.stub(:options).and_return({:daemonize => true})
-        @server.should_receive(:daemonize)
-        described_class.run
-      end
-      it "should call #kill_pid on new instance of self if kill option is true" do
-        Socky.stub(:options).and_return({:kill => true})
-        @server.should_receive(:kill_pid)
-        described_class.run
-      end
-    end
-    context "#new" do
-      it "should prepare options from args" do
-        begin
-          described_class.new(["-c", File.dirname(__FILE__) + "/../files/default.yml"])
-          Socky.options.class.should eql(Hash)
-          Socky.options.should_not be_empty
-        ensure
-          Socky.options = nil
-        end
-      end
-    end
-  end
-  
-  context "#instance" do
-    before(:each) do
-      Socky::Options.stub!(:prepare)
-      @runner = described_class.new
-    end
-    
-    context "#start" do
-      it "should create valid websocket server" do
-        begin
-          EM.run do
-            MSG = "Hello World!"
-            EventMachine.add_timer(0.1) do
-              http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
-              http.errback {
-                EM.stop
-                fail
-              }
-              http.callback {
-                http.response_header.status.should == 101
-                EM.stop
-              }
-            end
-          
-            Socky.stub!(:options).and_return({:port => 12345})
-            Socky.logger = mock(:logger, :info => nil, :debug => nil)
-            @runner.start
-          end
-        ensure
-          Socky.logger = nil
-        end
-      end
-    end
-    
-    it "#stop should call EM.stop" do
-      begin
-        Socky.logger = mock(:logger, :info => nil, :debug => nil)
-        EM.should_receive(:stop)
-        @runner.stop
-      ensure
-        Socky.logger = nil
-      end
-    end
-    
-  end
-end

data/spec/socky_spec.rb

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-describe Socky do
-  
-  context "class" do
-    
-    it "should have non-blank version" do
-      Socky::VERSION.should_not be_nil
-    end
-    it "should have options in hash form" do
-      Socky.options.should_not be_nil
-      Socky.options.class.should eql(Hash)
-    end
-    it "should allow to set options" do
-      Socky.options.should eql(Hash.new)
-      begin
-        Socky.options = {:key => :value}
-        Socky.options.should eql({:key => :value})
-      ensure
-        Socky.options = Hash.new
-      end
-    end
-    it "should have logger" do
-      Socky.logger.should_not be_nil
-      Socky.logger.class.should eql(Logger)
-    end
-    it "should have logger with STDOUT at default" do
-      Socky.logger.instance_variable_get('@logdev').dev.class.should eql(IO)
-    end
-    it "should be able to set logger" do
-      begin
-        logger = Logger.new(STDOUT)
-        Socky.logger.should_not equal(logger)
-        Socky.logger = logger
-        Socky.logger.should equal(logger)
-      ensure
-        Socky.logger = nil
-      end
-    end
-    it "should be able to change verbosity of logger by setting debug option" do
-      begin
-        Socky.logger.level.should eql(Logger::INFO)
-        Socky.logger = nil
-        Socky.stub!(:options).and_return({:debug => true})
-        Socky.logger.level.should eql(Logger::DEBUG)
-        Socky.logger = nil
-        Socky.stub!(:options).and_return({:debug => false})
-        Socky.logger.level.should eql(Logger::INFO)
-      ensure
-        Socky.logger = nil
-      end
-    end
-    it "should not have default log path" do
-      Socky.log_path.should be_nil
-    end
-    it "should be able to change log path by settion log_path option" do
-      Socky.stub!(:options).and_return({:log_path => "abstract"})
-      Socky.log_path.should eql("abstract")
-    end
-    it "should be able to change logger write place" do
-      begin
-        Socky.options = {:log_path => File.join(File.dirname(__FILE__), 'files', 'socky.log')}
-        Socky.logger.should_not be_nil
-        Socky.logger.instance_variable_get('@logdev').dev.class.should eql(File)
-      ensure
-        Socky.logger = nil
-        Socky.options = {}
-      end
-    end
-    it "should have default pid path" do
-      Socky.pid_path.should_not be_nil
-      Socky.pid_path.should eql("/var/run/socky.pid")
-    end
-    it "should be able to change pid path by settion pid_path option" do
-      Socky.stub!(:options).and_return({:pid_path => "abstract"})
-      Socky.pid_path.should eql("abstract")
-    end
-    it "should have default config path" do
-      Socky.config_path.should_not be_nil
-      Socky.config_path.should eql("/var/run/socky.yml")
-    end
-    it "should be able to change config path by settion config_path option" do
-      Socky.stub!(:options).and_return({:config_path => "abstract"})
-      Socky.config_path.should eql("abstract")
-    end
-    
-  end
-  
-end

data/spec/spec_helper.rb

@@ -1,6 +0,0 @@
-require 'rubygems'
-require 'spec'
-require "spec/autorun"
-
-require 'socky'
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

data/spec/support/stallion.rb

@@ -1,96 +0,0 @@
-# #--
-# Includes portion originally Copyright (C)2008 Michael Fellinger
-# license See file LICENSE for details
-# #--
-
-require 'rack'
-
-module Stallion
-  class Mount
-    def initialize(name, *methods, &block)
-      @name, @methods, @block = name, methods, block
-    end
-
-    def ride
-      @block.call
-    end
-
-    def match?(request)
-      method = request['REQUEST_METHOD']
-      right_method = @methods.empty? or @methods.include?(method)
-    end
-  end
-
-  class Stable
-    attr_reader :request, :response
-
-    def initialize
-      @boxes = {}
-    end
-
-    def in(path, *methods, &block)
-      mount = Mount.new(path, *methods, &block)
-      @boxes[[path, methods]] = mount
-      mount
-    end
-
-    def call(request, response)
-      @request, @response = request, response
-      @boxes.each do |(path, methods), mount|
-        if mount.match?(request)
-          mount.ride
-        end
-      end
-    end
-  end
-
-  STABLES = {}
-
-  def self.saddle(name = nil)
-    STABLES[name] = stable = Stable.new
-    yield stable
-  end
-
-  def self.run(options = {})
-    options = {:Host => "127.0.0.1", :Port => 8080}.merge(options)
-    Rack::Handler::Mongrel.run(Rack::Lint.new(self), options)
-  end
-
-  def self.call(env)
-    request = Rack::Request.new(env)
-    response = Rack::Response.new
-
-    STABLES.each do |name, stable|
-      stable.call(request, response)
-    end
-
-    response.finish
-  end
-end
-
-Stallion.saddle :spec do |stable|
-  stable.in '/' do
-
-    if stable.request.path_info == '/fail'
-      stable.response.status = 404
-
-    elsif stable.request.path_info == '/timeout'
-      sleep(10)
-      stable.response.write 'timeout'
-
-    elsif
-      stable.response.write  'Hello, World!'
-    end
-
-  end
-end
-
-Thread.new do
-  begin
-    Stallion.run :Host => '127.0.0.1', :Port => 8765
-  rescue Exception => e
-    print e
-  end
-end
-
-sleep(1)