socky 0.0.7 → 0.0.8

data/spec/socky/net_request_spec.rb

@@ -0,0 +1,43 @@
+require 'spec/spec_helper'
+require 'spec/stallion'
+
+describe Socky::NetRequest do
+  
+  context "class" do
+    context "#post" do
+      it "should send EventMachine::HttpRequest to url" do
+        EventMachine::HttpRequest.should_receive(:new).with("some url")
+        described_class.post("some url")
+      end
+      it "should send EventMachine::HttpRequest post request with specified params" do
+        request = mock(:request)
+        EventMachine::HttpRequest.stub!(:new).and_return(request)
+        request.should_receive(:post).with({:body => {:test => true}, :timeout => 3})
+        described_class.post("some url", :test => true)
+      end
+      it "should rescue from EM::HttpRequest and return false" do
+        EM.run do
+          described_class.post("inexistent").should be_false
+          EM.stop
+        end
+      end
+      it "should call block with false if request return status other than 200" do
+        EM.run do
+          described_class.post("http://127.0.0.1:8080/fail") do |response|
+            response.should be_false
+            EM.stop
+          end.should be_true
+        end
+      end
+      it "should call block with true if request return status 200" do
+        EM.run do
+          described_class.post("http://127.0.0.1:8080/") do |response|
+            response.should be_true
+            EM.stop
+          end.should be_true
+        end
+      end
+    end
+  end
+  
+end

data/spec/socky/options/config_spec.rb

@@ -0,0 +1,67 @@
+require 'spec/spec_helper'
+
+FILES_DIR = File.join(File.dirname(__FILE__), '..', '..', 'files')
+
+describe Socky::Options::Config do
+
+  context "class" do
+    before(:each) do
+      described_class.stub!(:puts)
+    end
+    
+    context "#read" do
+      it "should raise error if file doesn't exists" do
+        described_class.should_receive(:puts).with("You must generate a config file (socky -g filename.yml)")
+        lambda { described_class.read("abstract") }.should raise_error SystemExit
+      end
+      it "should raise error if file is corrupted" do
+        described_class.should_receive(:puts).with("Provided config file is invalid.")
+        lambda { described_class.read(FILES_DIR + "/invalid.yml") }.should raise_error SystemExit
+      end
+      it "should return valid options if file is valid" do
+        lambda { described_class.read(FILES_DIR + "/default.yml") }.should_not raise_error SystemExit
+        described_class.read(FILES_DIR + "/default.yml").should eql(default_options)
+      end
+    end
+    
+    context "#generate" do
+      it "should raise error if file exists" do
+        described_class.should_receive(:puts).with("Config file already exists. You must remove it before generating a new one.")
+        lambda { described_class.generate(FILES_DIR + "/invalid.yml") }.should raise_error SystemExit
+      end
+      it "should raise error if path is not valid" do
+        described_class.should_receive(:puts).with("Config file is unavailable - please choose another.")
+        lambda { described_class.generate("/proc/inexistent") }.should raise_error SystemExit
+      end
+      it "should create file and exit if path is valid" do
+        path = FILES_DIR + "/inexistent.yml"
+        begin
+          described_class.should_receive(:puts).with("Config file generated at #{path}")
+          lambda { described_class.generate(path) }.should raise_error SystemExit
+        ensure
+          FileUtils.rm(path, :force => true)
+        end
+      end
+      it "should generate file that after parsing will equal default config" do
+        path = FILES_DIR + "/inexistent.yml"
+        begin
+          described_class.should_receive(:puts).with("Config file generated at #{path}")
+          lambda { described_class.generate(path) }.should raise_error SystemExit
+          lambda { described_class.read(path) }.should_not raise_error SystemExit
+          described_class.read(path).should eql(default_options)
+        ensure
+          FileUtils.rm(path, :force => true)
+        end
+      end
+    end
+  end
+end
+
+def default_options
+  { :port => 8080,
+    :debug => false,
+    :subscribe_url => "http://localhost:3000/socky/subscribe",
+    :unsubscribe_url => "http://localhost:3000/socky/unsubscribe",
+    :secret => "my_secret_key"
+  }
+end

data/spec/socky/options/parser_spec.rb

@@ -0,0 +1,59 @@
+require 'spec/spec_helper'
+
+describe Socky::Options::Parser do
+  
+  context "class" do
+    context "#parse" do
+      before(:each) do
+        described_class.stub!(:puts)
+      end
+      
+      it "should return empty hash on empty array" do
+        described_class.parse([]).should eql({})
+      end
+      it "should inform about inexistent option and exit" do
+        described_class.should_receive(:puts).with("invalid option: -z")
+        lambda { described_class.parse(["-z"]) }.should raise_error SystemExit
+      end
+      it "on -g or --generate should set config_path and generate default config file in specified destination" do
+        Socky::Options::Config.stub!(:generate)
+        ["-g","--generate"].each do |function|
+          Socky::Options::Config.should_receive(:generate).with("/tmp/socky.yml")
+          described_class.parse([function,"/tmp/socky.yml"]).should eql({:config_path => "/tmp/socky.yml"})
+        end
+      end
+      it "on -c or --config should set config_path to provided path" do
+        ["-c","--config"].each do |function|
+          described_class.parse([function,"/tmp/socky.yml"]).should eql({:config_path => "/tmp/socky.yml"})
+        end
+      end
+      it "on -p or --port should set port" do
+        described_class.parse(["-p","222"]).should eql({:port => 222})
+      end
+      it "on -l or --log should set log_path to provided path" do
+        ["-l","--log"].each do |function|
+          described_class.parse([function,"/tmp/socky.log"]).should eql({:log_path => "/tmp/socky.log"})
+        end
+      end
+      it "on --debug should set debug to true" do
+        described_class.parse(["--debug"]).should eql({:debug => true})
+      end
+      it "on --deep-debug should set debug and deep_debug to true" do
+        described_class.parse(["--deep-debug"]).should eql({:debug => true, :deep_debug => true})
+      end
+      it "on -? or --help should display usage" do
+        ["-?","--help"].each do |function|
+          described_class.should_receive(:puts).with(/Usage: socky \[options\]/)
+          lambda { described_class.parse([function]) }.should raise_error SystemExit
+        end
+      end
+      it "on -v or --version should dosplay current version" do
+        ["-v","--version"].each do |function|
+          described_class.should_receive(:puts).with("Socky #{Socky::VERSION}")
+          lambda { described_class.parse([function]) }.should raise_error SystemExit
+        end
+      end
+      
+    end
+  end
+end

data/spec/socky/options_spec.rb

@@ -0,0 +1,65 @@
+require 'spec/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")
+        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({:port=>8080,
+                                  :log_path=>"/var/run/socky.log",
+                                  :debug=>false,
+                                  :deep_debug=>false,
+                                  :config_path=>"/var/run/socky.yml"})
+      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({:port=>8080,
+                                  :log_path=>"parsed",
+                                  :debug=>false,
+                                  :deep_debug=>false,
+                                  :config_path=>"/var/run/socky.yml"})
+      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({:port=>8080,
+                                  :log_path=>"from config",
+                                  :debug=>false,
+                                  :deep_debug=>false,
+                                  :config_path=>"/var/run/socky.yml"})
+      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({:port=>8080,
+                                  :log_path=>"parsed",
+                                  :debug=>false,
+                                  :deep_debug=>false,
+                                  :config_path=>"/var/run/socky.yml"})
+      end
+    end
+  end
+
+end

data/spec/socky/runner_spec.rb

@@ -0,0 +1,73 @@
+require 'spec/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" do
+        @server.should_receive(:start)
+        described_class.run
+      end
+    end
+    context "#new" do
+      it "should prepare options from args" do
+        Socky::Options.stub!(:prepare)
+        Socky::Options.should_receive(:prepare).with("some args")
+        described_class.new("some args")
+      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/server_spec.rb

@@ -0,0 +1,35 @@
+require 'spec/spec_helper'
+
+describe Socky::Server do
+  
+  context "class" do
+    it "#send_data should call send_message on each of provided connections" do
+      connections = []
+      3.times {|i| connections << mock("connection#{i}", :send_message => nil)}
+      connections.each{|connection| connection.should_receive(:send_message).with("abstract")}
+      described_class.send_data("abstract",connections)
+    end
+    it "#send_to_clients should find connections by clients and call #send_data on them" do
+      Socky::Connection.stub!(:find_by_clients).and_return(["first","second","third"])
+      described_class.stub!(:send_data)
+      Socky::Connection.should_receive(:find_by_clients).with("abstract")
+      described_class.should_receive(:send_data).with("message", ["first","second","third"])
+      described_class.send_to_clients("message","abstract")
+    end
+    it "#send_to_channels should find connections by channels and call #send_data on them" do
+      Socky::Connection.stub!(:find_by_channels).and_return(["first","second","third"])
+      described_class.stub!(:send_data)
+      Socky::Connection.should_receive(:find_by_channels).with("abstract")
+      described_class.should_receive(:send_data).with("message", ["first","second","third"])
+      described_class.send_to_channels("message","abstract")
+    end
+    it "#send_to_clients_on_channels should find connections by clients and channels and call #send_data on them" do
+      Socky::Connection.stub!(:find_by_clients_and_channels).and_return(["first","second","third"])
+      described_class.stub!(:send_data)
+      Socky::Connection.should_receive(:find_by_clients_and_channels).with("abstract1","abstract2")
+      described_class.should_receive(:send_data).with("message", ["first","second","third"])
+      described_class.send_to_clients_on_channels("message","abstract1","abstract2")
+    end
+  end
+  
+end

data/spec/socky_spec.rb

@@ -0,0 +1,82 @@
+require 'spec/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 have default log path" do
+      Socky.log_path.should_not be_nil
+      Socky.log_path.should eql("/var/run/socky.log")
+    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 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

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

data/spec/stallion.rb

@@ -0,0 +1,96 @@
+# #--
+# 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 => 8080
+  rescue Exception => e
+    print e
+  end
+end
+
+sleep(1)