socky-server 0.4.0

data/spec/socky/connection_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+describe Socky::Connection do
+
+  context "class" do
+    it "should have connections array" do
+      described_class.connections.should_not be_nil
+      described_class.connections.class.should eql(Array)
+    end
+    it "should have empty connections array at start" do
+      described_class.connections.should be_empty
+    end
+    it "should create instance and assign socket to self" do
+      socket = mock(:socket)
+      connection = described_class.new(socket)
+      connection.socket.should equal(socket)
+    end
+  end
+
+  context "instance" do
+    before(:each) do
+      described_class.connections.clear
+      socket = mock(:socket, :request => { "Query" => {}})
+      @connection = described_class.new(socket)
+    end
+    
+    context "#admin" do
+      it "should return true for socket request data admin equal to '1' and 'true'" do
+        ["1","true"].each do |value|
+          @connection.socket.request["Query"]["admin"] = value
+          @connection.admin.should be_true
+        end
+      end
+      it "should return false for socket request data admin equal to anything except '1' and 'true'" do
+        [nil,"0","false","abstract"].each do |value|
+          @connection.socket.request["Query"]["admin"] = value
+          @connection.admin.should be_false
+        end
+      end
+      it "should return false if socket request data is nil" do
+        @connection.socket.request["Query"] = nil
+        @connection.admin.should be_false
+      end
+    end
+    it "#client should return client_id from socket request data" do
+      @connection.socket.request["Query"]["client_id"] = "abstract"
+      @connection.client.should eql("abstract")
+    end
+    it "#secret should return client_secret from socket request data" do
+      @connection.socket.request["Query"]["client_secret"] = "abstract"
+      @connection.secret.should eql("abstract")
+    end
+    context "#channels" do
+      it "should ba array" do
+        @connection.channels.should_not be_nil
+        @connection.channels.class.should eql(Array)
+      end
+      it "should return table with nil if socket request data 'channels' is nil" do
+        @connection.socket.request["Query"]["channels"] = nil
+        @connection.channels.should eql([nil])
+      end
+      it "should return table of channels if provided and separated by comma" do
+        @connection.socket.request["Query"]["channels"] = "aaa,bbb,ccc"
+        @connection.channels.should eql(["aaa","bbb","ccc"])
+      end
+      it "should not allow empty names of channels" do
+        @connection.socket.request["Query"]["channels"] = "aaa,,ccc"
+        @connection.channels.should eql(["aaa","ccc"])
+      end
+      it "should strip trailing spaces in channel names" do
+        @connection.socket.request["Query"]["channels"] = "  aaa\n  , \n , ccc  "
+        @connection.channels.should eql(["aaa","ccc"])
+      end
+    end
+    it "#subscribe should send subscribe request" do
+      @connection.stub!(:subscribe_request)
+      @connection.should_receive(:subscribe_request)
+      @connection.subscribe
+    end
+    it "#unsubscribe should send unsubscribe request" do
+      @connection.stub!(:unsubscribe_request)
+      @connection.should_receive(:unsubscribe_request)
+      @connection.unsubscribe
+    end
+    context "#process_message" do
+      it "should send process request to socky message class if connection is by admin" do
+        @connection.stub!(:admin).and_return(true)
+        Socky::Message.stub!(:process)
+        Socky::Message.should_receive(:process).with(@connection, "abstract")
+        @connection.process_message("abstract")
+      end
+      it "should send user message that he can not send messages if connection is not admin" do
+        @connection.stub!(:admin).and_return(false)
+        @connection.stub!(:send_message)
+        @connection.should_receive(:send_message).with("You are not authorized to post messages")
+        @connection.process_message("abstract")
+      end
+    end
+    it "#send_message should call #send_data with hashed form of message" do
+      @connection.should_receive(:send_data).with({:type => :message, :body => "abstract"})
+      @connection.send_message("abstract")
+    end
+    it "#send_data should send message by socket in json format" do
+      @connection.socket.stub!(:send)
+      @connection.socket.should_receive(:send).with({:test => "abstract"}.to_json)
+      @connection.send(:send_data, {:test => "abstract"})
+    end
+    it "#disconnect should close connection after writing" do
+      @connection.socket.stub!(:close_connection_after_writing)
+      @connection.socket.should_receive(:close_connection_after_writing)
+      @connection.disconnect
+    end
+    context "#add_to_pool" do
+      it "should add self to class connection list if self isn't already on list or self isn't admin" do
+        @connection.stub!(:admin).and_return(false)
+        @connection.send(:add_to_pool)
+        described_class.connections.should include(@connection)
+        described_class.connections.should have(1).item
+      end
+      it "should not add self to class connection list if self is already on it" do
+        described_class.connections << @connection
+        described_class.connections.should have(1).item
+        @connection.stub!(:admin).and_return(false)
+        @connection.send(:add_to_pool)
+        described_class.connections.should include(@connection)
+        described_class.connections.should have(1).item
+      end
+      it "should not add self to class connection list if self is admin" do
+        @connection.stub!(:admin).and_return(true)
+        @connection.send(:add_to_pool)
+        described_class.connections.should_not include(@connection)
+      end
+    end
+    it "#remove_from_pool should delete self from class connection list" do
+      described_class.connections << @connection
+      described_class.connections.should have(1).item
+      @connection.send(:remove_from_pool)
+      described_class.connections.should_not include(@connection)
+      described_class.connections.should have(0).items
+    end
+    it "#to_json should return self as hash of object_id, client_id and channels" do
+      @connection.socket.request["Query"]["client_id"] = "abstract"
+      @connection.socket.request["Query"]["channels"] = "first,second,third"
+      json = @connection.to_json
+      JSON.parse(json).should eql({ "id" => @connection.object_id,
+                                    "client_id" => @connection.client,
+                                    "channels" => @connection.channels})
+    end
+  end
+
+end

data/spec/socky/message_spec.rb

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,76 @@
+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