socky-server 0.4.1 → 0.5.0.beta1

data/spec/socky/message_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Message do
-  before(:each) do
-    @connection = mock(:connection, :name => "connection", :send_message => nil)
-  end
-  
-  context "class" do
-    context "#process" do
-      before(:each) { @message = mock(:message, :process => nil) }
-      it "should create new instance of self with provided params" do
-        described_class.stub!(:new).and_return(@message)
-        described_class.should_receive(:new).with(@connection, "test")
-        described_class.process(@connection, "test")
-      end
-      it "should send #process to instance if valid message" do
-        described_class.stub!(:new).and_return(@message)
-        @message.should_receive(:process)
-        described_class.process(@connection, "test")
-      end
-      it "should rescue from error if creating instance raise error" do
-        described_class.stub!(:new).and_raise(Socky::SockyError)
-        lambda{ described_class.process(@connection, "test") }.should_not raise_error
-      end
-      it "should rescue from error if parsing instance raise error" do
-        @message.stub!(:process).and_raise(Socky::SockyError)
-        described_class.stub!(:new).and_return(@message)
-        lambda{ described_class.process(@connection, "test") }.should_not raise_error
-      end
-    end
-    context "#new" do
-      it "should create message with provided creator and message is message is JSON hash" do
-        message = described_class.new(@connection, {:test => true}.to_json)
-        message.params.should eql(:test => true)
-        message.creator.should eql(@connection)
-      end
-      it "should raise error if message is not JSON" do
-        lambda{described_class.new(@connection, {:test => true})}.should raise_error Socky::SockyError
-        lambda{described_class.new(@connection, "test")}.should raise_error Socky::SockyError
-      end
-      it "should raise error if message is JSON but not JSON hash" do
-        lambda{described_class.new(@connection, "test".to_json)}.should raise_error Socky::SockyError
-      end
-    end
-  end
-  
-  context "instance" do
-    before(:each) { @message = described_class.new(@connection, {}.to_json) }
-    context "#process" do
-      before(:each) do
-        @message.stub!(:send_message)
-      end
-      it "should raise error if message command is nil" do
-        @message.stub!(:params).and_return({:command => nil})
-        lambda {@message.process}.should raise_error(Socky::SockyError, "unknown command")
-      end
-      it "should raise error if message command is neither :broadcast nor :query" do
-        @message.stub!(:params).and_return({:command => :invalid})
-        lambda {@message.process}.should raise_error(Socky::SockyError, "unknown command")
-      end
-      it "should not distinguish between string and symbol in command" do
-        @message.stub!(:params).and_return({:command => 'broadcast'})
-        lambda {@message.process}.should_not raise_error(Socky::SockyError, "unknown command")
-      end
-      context ":broadcast" do
-        it "should select target connections basing on params" do
-          @message.stub!(:params).and_return({:command => :broadcast, :some => :abstract})
-          Socky::Connection.should_receive(:find).with(:some => :abstract)
-          @message.process
-        end
-        it "should send_message with message body and connection list" do
-          @message.stub!(:params).and_return({:command => :broadcast, :body => "some message"})
-          Socky::Connection.stub!(:find).and_return(["first","second"])
-          @message.should_receive(:send_message).with("some message", ["first", "second"])
-          @message.process
-        end
-      end
-      context ":query" do
-        it "should raise error if query type is nil" do
-          @message.stub!(:params).and_return(:command => :query, :type => nil)
-          lambda{ @message.process }.should raise_error(Socky::SockyError, "unknown query type")
-        end
-        it "should raise error if query type is invalid" do
-          @message.stub!(:params).and_return(:command => :query, :type => :invalid)
-          lambda{ @message.process }.should raise_error(Socky::SockyError, "unknown query type")
-        end
-        it "should not distinguish between string and symbol in command" do
-          @message.stub!(:params).and_return({:command => :query, :type => "show_connections"})
-          lambda {@message.process}.should_not raise_error(Socky::SockyError, "unknown query type")
-        end
-        context "=> :show_connections" do
-          it "should return current connection list to creator" do
-            @message.stub!(:params).and_return(:command => :query, :type => :show_connections)
-            Socky::Connection.stub!(:find_all).and_return(["find results"])
-            @connection.should_receive(:send_message).with(["find results"])
-            @message.process
-          end
-        end
-      end
-    end
-  end
-end

data/spec/socky/misc_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Misc do
-  include Socky::Misc
-  
-  shared_examples_for "socky_misc" do
-    it "#option should return Socky.options" do
-      Socky.stub!(:options).and_return({:test => true})
-      @object.options.should eql({:test => true})
-    end
-    it "#options= should set Socky.options" do
-      default_options = Socky.options
-      begin
-        Socky.options = {}
-        @object.options = {:test => true}
-        Socky.options.should eql({:test => true})
-      ensure
-        Socky.options = default_options
-      end
-    end
-    it "#name should return self formatted name" do
-      @object.name.should eql("#{@object.class.to_s.split("::").last}(#{@object.object_id})")
-    end
-    it "#log_path should return Socky.log_path" do
-      Socky.stub!(:log_path).and_return("abstract")
-      @object.log_path.should eql("abstract")
-    end
-    it "#config_path should return Socky.config_path" do
-      Socky.stub!(:config_path).and_return("abstract")
-      @object.config_path.should eql("abstract")
-    end
-    it "#info should send joined args to Socky.logger.info" do
-      Socky.logger.stub!(:info)
-      Socky.logger.should_receive(:info).with("first second third")
-      @object.info(["first","second","third"])
-    end
-    it "#debug should send joined args to Socky.logger.debug" do
-      Socky.logger.stub!(:debug)
-      Socky.logger.should_receive(:debug).with("first second third")
-      @object.debug(["first","second","third"])
-    end
-    it "#error should send self name and error message to self.debug" do
-      @object.stub!(:debug)
-      error = mock(:abstract_error, :class => "AbstractError", :message => "abstract")
-      @object.should_receive(:debug).with([@object.name,"raised:","AbstractError","abstract"])
-      @object.error(@object.name, error)
-    end
-    context "#symbolize_keys" do
-      it "return args if args are not hash" do
-        @object.symbolize_keys("abstract").should eql("abstract")
-      end
-      it "return hash with symbolized keys if args is hash" do
-        hash = {"aaa" => "a", 123 => "b"}
-        @object.symbolize_keys(hash).should eql({:aaa => "a", 123 => "b"})
-      end
-    end
-  end
-
-  context "class" do
-    before(:each) do
-      @object = self.class
-    end
-    it_should_behave_like "socky_misc"
-  end
-
-  context "instance" do
-    before(:each) do
-      @object = self
-    end
-    it_should_behave_like "socky_misc"
-  end
-  
-end
-      

data/spec/socky/net_request_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-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:8765/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:8765/") do |response|
-            response.should be_true
-            EM.stop
-          end.should be_true
-        end
-      end
-    end
-  end
-  
-end

data/spec/socky/options/config_spec.rb

@@ -1,72 +0,0 @@
-require '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 not raise error if :kill option is provided" do
-        described_class.should_not_receive(:puts).with("Provided config file is invalid.")
-        lambda { described_class.read(FILES_DIR + "/invalid.yml", :kill => true) }.should_not 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
-  
-  def default_options
-    {
-      :port => 8080,
-      :debug => false,
-      :secret => "my_secret_key",
-      :secure => false
-    }
-  end
-  
-end

data/spec/socky/options/parser_spec.rb

@@ -1,76 +0,0 @@
-require '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
-        ["-p","--port"].each do |function|
-          described_class.parse([function,"222"]).should eql({:port => 222})
-        end
-      end
-      it "on -s or --secure should set secure mode on" do
-        ["-s","--secure"].each do |function|
-          described_class.parse([function]).should eql({:secure => true})
-        end
-      end
-      it "on -P or --pid should set pid_path to provided path" do
-        ["-P","--pid"].each do |function|
-          described_class.parse([function,"/tmp/socky.pid"]).should eql({:pid_path => "/tmp/socky.pid"})
-        end
-      end
-      it "on -d or --daemon should set daemon mode on" do
-        ["-d","--daemon"].each do |function|
-          described_class.parse([function]).should eql({:daemonize => true})
-        end
-      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

@@ -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