socky 0.0.7 → 0.0.8

data/spec/socky/connection_spec.rb

@@ -0,0 +1,143 @@
+require 'spec/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
+    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 empty table if socket request data 'channels' is nil" do
+        @connection.socket.request["Query"]["channels"] = nil
+        @connection.channels.should eql([])
+      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 send message by socket" do
+      @connection.socket.stub!(:send)
+      @connection.socket.should_receive(:send).with("abstract")
+      @connection.send_message("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.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.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.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.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,260 @@
+require 'spec/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!(:verify_secret!)
+        @message.stub!(:execute)
+      end
+      it "should verify secret" do
+        @message.should_receive(:verify_secret!)
+        @message.process
+      end
+      it "should execute" do
+        @message.should_receive(:execute)
+        @message.process
+      end
+    end
+    context "#verify_secret!" do
+      it "should not raise error if socky option :secret is nil" do
+        Socky.stub!(:options).and_return({:secret => nil})
+        lambda{ @message.verify_secret! }.should_not raise_error Socky::SockyError
+      end
+      it "should raise error if socky options :secret is not nil but message secret have different value" do
+        Socky.stub!(:options).and_return({:secret => "test"})
+        @message.stub!(:options).and_return({:secret => "another"})
+        lambda{ @message.verify_secret! }.should raise_error Socky::SockyError
+      end
+      it "should not raise error if socky options :secret is not nil and message secret have the some value" do
+        Socky.stub!(:options).and_return({:secret => "test"})
+        @message.stub!(:params).and_return({:secret => "test"})
+        lambda{ @message.verify_secret! }.should_not raise_error Socky::SockyError
+      end
+    end
+    context "#execute" do
+      it "should call #broadcast if message command is :broadcast" do
+        @message.stub!(:params).and_return({:command => :broadcast})
+        @message.stub!(:broadcast)
+        @message.should_receive(:broadcast)
+        @message.execute
+      end
+      it "should not distinguish between string and symbol in command" do
+        @message.stub!(:params).and_return({:command => 'broadcast'})
+        @message.stub!(:broadcast)
+        @message.should_receive(:broadcast)
+        @message.execute
+      end
+      it "should call #query if message command is :query" do
+        @message.stub!(:params).and_return({:command => :query})
+        @message.stub!(:query)
+        @message.should_receive(:query)
+        @message.execute
+      end
+      it "should raise error if message command is nil" do
+        @message.stub!(:params).and_return({:command => nil})
+        lambda {@message.execute}.should raise_error Socky::SockyError
+      end
+      it "should raise error if message command is neither :broadcast nor :query" do
+        @message.stub!(:params).and_return({:command => "invalid"})
+        lambda {@message.execute}.should raise_error Socky::SockyError
+      end
+    end
+    context "#broadcast" do
+      it "should call #broadcast_to_clients if message type is :to_clients" do
+        @message.stub!(:params).and_return({:type => :to_clients})
+        @message.stub!(:broadcast_to_clients)
+        @message.should_receive(:broadcast_to_clients)
+        @message.broadcast
+      end
+      it "should not distinguish between string and symbol in type" do
+        @message.stub!(:params).and_return({:type => 'to_clients'})
+        @message.stub!(:broadcast_to_clients)
+        @message.should_receive(:broadcast_to_clients)
+        @message.broadcast
+      end
+      it "should call #broadcast_to_channels if message type is :to_channels" do
+        @message.stub!(:params).and_return({:type => :to_channels})
+        @message.stub!(:broadcast_to_channels)
+        @message.should_receive(:broadcast_to_channels)
+        @message.broadcast
+      end
+      it "should call #broadcast_to_clients_on_channels if message type is :to_clients_on_channels" do
+        @message.stub!(:params).and_return({:type => :to_clients_on_channels})
+        @message.stub!(:broadcast_to_clients_on_channels)
+        @message.should_receive(:broadcast_to_clients_on_channels)
+        @message.broadcast
+      end
+      it "should raise error if message type is nil" do
+        @message.stub!(:params).and_return({:type => nil})
+        lambda {@message.broadcast}.should raise_error Socky::SockyError
+      end
+      it "should raise error if message type is not one of :to_clients, :to_channels or :to_cleints_on_channels" do
+        @message.stub!(:params).and_return({:type => "invalid"})
+        lambda {@message.broadcast}.should raise_error Socky::SockyError
+      end
+    end
+    context "#broadcast_to_clients" do
+      before(:each) do
+        @message.stub!(:verify)
+        Socky::Server.stub!(:send_to_clients)
+      end
+      it "should verify :clients params existence" do
+        @message.should_receive(:verify).with(:clients)
+        @message.broadcast_to_clients
+      end
+      it "should call socky server #send_to_clients with own params" do
+        @message.stub!(:params).and_return(:body => "some message", :clients => "some clients")
+        Socky::Server.should_receive(:send_to_clients).with("some message", "some clients")
+        @message.broadcast_to_clients
+      end
+    end
+    context "#broadcast_to_channels" do
+      before(:each) do
+        @message.stub!(:verify)
+        Socky::Server.stub!(:send_to_channels)
+      end
+      it "should verify :channels params existence" do
+        @message.should_receive(:verify).with(:channels)
+        @message.broadcast_to_channels
+      end
+      it "should call socky server #send_to_channels with own params" do
+        @message.stub!(:params).and_return(:body => "some message", :channels => "some channels")
+        Socky::Server.should_receive(:send_to_channels).with("some message", "some channels")
+        @message.broadcast_to_channels
+      end
+    end
+    context "#broadcast_to_clients_on_channels" do
+      before(:each) do
+        @message.stub!(:verify)
+        Socky::Server.stub!(:send_to_clients_on_channels)
+      end
+      it "should verify :clients params existence" do
+        @message.should_receive(:verify).with(:clients)
+        @message.broadcast_to_clients_on_channels
+      end
+      it "should verify :channels params existence" do
+        @message.should_receive(:verify).with(:channels)
+        @message.broadcast_to_clients_on_channels
+      end
+      it "should call socky server #send_to_clients_on_channels with own params" do
+        @message.stub!(:params).and_return(:body => "some message", :clients => "some clients", :channels => "some channels")
+        Socky::Server.should_receive(:send_to_clients_on_channels).with("some message", "some clients", "some channels")
+        @message.broadcast_to_clients_on_channels
+      end
+    end
+    context "#query" do
+      it "should call #query_show_connections if message type is :show_connections" do
+        @message.stub!(:params).and_return({:type => :show_connections})
+        @message.stub!(:query_show_connections)
+        @message.should_receive(:query_show_connections)
+        @message.query
+      end
+      it "should not distinguish between string and symbol in type" do
+        @message.stub!(:params).and_return({:type => 'show_connections'})
+        @message.stub!(:query_show_connections)
+        @message.should_receive(:query_show_connections)
+        @message.query
+      end
+      it "should raise error if message type is nil" do
+        @message.stub!(:params).and_return({:type => nil})
+        lambda{ @message.query }.should raise_error Socky::SockyError
+      end
+      it "should raise error if message type is not :show_connections" do
+        @message.stub!(:params).and_return({:type => "invalid"})
+        lambda{ @message.query }.should raise_error Socky::SockyError
+      end
+    end
+    context "#query_show_connections" do
+      before(:each) do
+        Socky::Connection.stub!(:find_all).and_return("find results")
+        @message.stub!(:respond)
+      end
+      it "should ask for all connections" do
+        Socky::Connection.should_receive(:find_all)
+        @message.query_show_connections
+      end
+      it "should respond current connection list" do
+        @message.should_receive(:respond).with("find results")
+        @message.query_show_connections
+      end
+    end
+    context "#verify" do
+      it "should convert posted field to empty array if field is nil" do
+        @message.params[:clients] = nil
+        @message.verify :clients
+        @message.params[:clients].should eql([])
+      end
+      it "should convert posted field to array containing field value if field is not array" do
+        @message.params[:clients] = "some client"
+        @message.verify :clients
+        @message.params[:clients].should eql(["some client"])
+      end
+      it "should not convert field if field is array" do
+        @message.params[:clients] = ["some client"]
+        @message.verify :clients
+        @message.params[:clients].should eql(["some client"])
+      end
+      it "should change every array value to string" do
+        @message.params[:clients] = [1,2,3]
+        @message.verify :clients
+        @message.params[:clients].should eql(["1","2","3"])
+      end
+    end
+    context "#respond" do
+      it "should call creator #send_message" do
+        @connection.should_receive(:send_message)
+        @message.respond({:test => true})
+      end
+      it "should convert message to json" do
+        @connection.should_receive(:send_message).with({:test => true}.to_json)
+        @message.respond({:test => true})
+      end
+    end
+
+  end
+end

data/spec/socky/misc_spec.rb

@@ -0,0 +1,74 @@
+require 'spec/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
+