socky-server 0.4.1 → 0.5.0.beta1

data/spec/files/default.yml

@@ -1,18 +0,0 @@
-:port: 8080
-:debug: false
-
-# :subscribe_url: http://localhost:3000/socky/subscribe
-# :unsubscribe_url: http://localhost:3000/socky/unsubscribe
-
-:secret: my_secret_key
-
-:secure: false
-
-# :timeout: 3
-
-# :log_path: /var/log/socky.log
-# :pid_path: /var/run/socky.pid
-
-# :tls_options:
-#   :private_key_file: /private/key
-#   :cert_chain_file: /ssl/certificate

data/spec/files/invalid.yml

@@ -1 +0,0 @@
-invalid data

data/spec/socky/connection/authentication_spec.rb

@@ -1,183 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Connection::Authentication do
-  include Socky::Connection::Authentication
-  
-  context "instance" do
-    context "#subscribe_request" do
-      before(:each) do
-        stub!(:admin).and_return(false)
-        stub!(:send_data)
-      end
-      it "should not call #send_subscribe_request if already authenticated" do
-        stub!(:authenticated?).and_return(true)
-        should_not_receive(:send_subscribe_request)
-        subscribe_request
-      end
-      it "should call #send_subscribe_request if unauthenticated" do
-        stub!(:authenticated?).and_return(false)
-        should_receive(:send_subscribe_request)
-        subscribe_request
-      end
-      it "should add self to connection list if #send_subscribe_request block is true" do
-        EM.run do
-          stub!(:authenticated?).and_return(false)
-          stub!(:send_subscribe_request).and_yield(true)
-          should_receive(:add_to_pool)
-          subscribe_request
-          EM.stop
-        end
-      end
-      it "should be authenticated by url if #send_subscribe_request block is true" do
-        EM.run do
-          stub!(:authenticated?).and_return(false)
-          stub!(:send_subscribe_request).and_yield(true)
-          stub!(:add_to_pool)
-          subscribe_request
-          authenticated_by_url?.should be_true
-          EM.stop
-        end
-      end
-      it "should disconnect if #send_subscribe_request block is false" do
-        EM.run do
-          stub!(:send_subscribe_request).and_yield(false)
-          should_receive(:disconnect)
-          subscribe_request
-          EM.add_timer(0.1) do
-            EM.stop
-          end
-        end
-      end
-    end
-    context "#unsubscribe_request" do
-      it "should remove self from connection list if authenticated" do
-        stub!(:admin).and_return(false)
-        stub!(:authenticated?).and_return(true)
-        should_receive(:remove_from_pool)
-        unsubscribe_request
-      end
-      it "should send unsubscribe request if authenticated but not admin" do
-        stub!(:admin).and_return(false)
-        stub!(:authenticated?).and_return(true)
-        stub!(:remove_from_pool)
-        should_receive(:send_unsubscribe_request)
-        unsubscribe_request
-      end
-      it "should not send unsubscribe request if authenticated and admin" do
-        stub!(:admin).and_return(true)
-        stub!(:authenticated?).and_return(true)
-        stub!(:remove_from_pool)
-        should_not_receive(:send_unsubscribe_request)
-        unsubscribe_request
-      end
-      it "should not send unsubscribe request if unauthenticated" do
-        stub!(:authenticated?).and_return(false)
-        should_not_receive(:send_unsubscribe_request)
-        unsubscribe_request
-      end
-    end
-    context "#authenticated?" do
-      it "should authenticate as admin if admin" do
-        stub!(:admin).and_return(true)
-        should_receive(:authenticate_as_admin)
-        authenticated?
-      end
-      it "should authenticate as user if not admin" do
-        stub!(:admin).and_return(false)
-        should_receive(:authenticate_as_user)
-        authenticated?
-      end
-    end
-    context "#authenticate_as_admin" do
-      it "should return true if client secret is equal server secret" do
-        stub!(:secret).and_return("test")
-        Socky.stub!(:options).and_return({:secret => "test"})
-        authenticate_as_admin.should be_true
-      end
-      it "should return false if client secret is not equal server secret" do
-        stub!(:secret).and_return("abstract")
-        Socky.stub!(:options).and_return({:secret => "test"})
-        authenticate_as_admin.should be_false
-      end
-      it "should return true if server secret is nil" do
-        stub!(:secret).and_return("abstract")
-        Socky.stub!(:options).and_return({:secret => nil})
-        authenticate_as_admin.should be_true
-      end
-    end
-    it "#authenticate_as_user should call #authenticated_by_url?" do
-      should_receive(:authenticated_by_url?)
-      authenticate_as_user
-    end
-    it "#authenticated_by_url? should return current status" do
-      instance_variable_set('@authenticated_by_url',true)
-      authenticated_by_url?.should be_true
-      instance_variable_set('@authenticated_by_url',false)
-      authenticated_by_url?.should be_false
-    end
-    context "#send_subscribe_request" do
-      it "should build params for request if socky option subscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:subscribe_url => "any"})
-        should_receive(:params_for_request)
-        send_subscribe_request
-      end
-      it "should call Socky::NetRequest#post if socky option subscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:subscribe_url => "any"})
-        stub!(:params_for_request)
-        Socky::NetRequest.should_receive(:post)
-        send_subscribe_request
-      end
-      it "should not call Socky::NetRequest#post if socky option subscribe_url is nil" do
-        Socky.stub!(:options).and_return({:subscribe_url => nil})
-        Socky::NetRequest.should_not_receive(:post)
-        send_subscribe_request{}
-      end
-    end
-    context "#send_unsubscribe_request" do
-      it "should build params for request if socky option unsubscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:unsubscribe_url => "any"})
-        should_receive(:params_for_request)
-        send_unsubscribe_request{}
-      end
-      it "should call Socky::NetRequest#post if socky option unsubscribe_url is not nil" do
-        Socky.stub!(:options).and_return({:unsubscribe_url => "any"})
-        stub!(:params_for_request)
-        Socky::NetRequest.should_receive(:post)
-        send_unsubscribe_request{}
-      end
-      it "should not call Socky::NetRequest#post if socky option unsubscribe_url is nil" do
-        Socky.stub!(:options).and_return({:unsubscribe_url => nil})
-        Socky::NetRequest.should_not_receive(:post)
-        send_unsubscribe_request{}
-      end
-    end
-    context "#params_for_request" do
-      before(:each) do
-        stub!(:client)
-        stub!(:secret)
-        stub!(:channels).and_return([])
-      end
-      it "should return empty hash if none of (client,secret,channels) are set" do
-        params_for_request.should eql({})
-      end
-      it "should return client as client_id if set" do
-        stub!(:client).and_return("some client")
-        params_for_request.should eql({:client_id => "some client"})
-      end
-      it "should return secret as client_secret if set" do
-        stub!(:secret).and_return("some secret")
-        params_for_request.should eql({:client_secret => "some secret"})
-      end
-      it "should return channels if not empty" do
-        stub!(:channels).and_return(["some channel"])
-        params_for_request.should eql({:channels => ["some channel"]})
-      end
-      it "should return client, secret and channels as hash if all are set" do
-        stub!(:client).and_return("some client")
-        stub!(:secret).and_return("some secret")
-        stub!(:channels).and_return(["some channel"])
-        params_for_request.should eql({:client_id => "some client", :client_secret => "some secret", :channels => ["some channel"]})
-      end
-    end
-  end
-end

data/spec/socky/connection/finders_spec.rb

@@ -1,188 +0,0 @@
-require 'spec_helper'
-
-describe Socky::Connection::Finders do
-  include Socky::Connection::Finders
-  include Socky::Misc
-  
-  context "class" do
-    before(:each) do
-      @connection1 = mock(:connection1, :client => "client1", :channels => [nil])
-      @connection2 = mock(:connection2, :client => "client1", :channels => ["1", "3", "5"])
-      @connection3 = mock(:connection3, :client => "client2", :channels => ["2", "5"])
-      @connection4 = mock(:connection4, :client => "client3", :channels => ["3", "5"])
-      @connections = [@connection1,@connection2,@connection3,@connection4]
-      @connections.collect { |connection| Socky::Connection.connections << connection }
-    end
-    after(:each) do
-      Socky::Connection.connections.clear
-    end
-    
-    it "#find_all should return all connections" do
-      find_all.should eql(@connections)
-    end
-    context "#find" do
-      it "should return all connections if no options specified" do
-        find.should eql(@connections)
-      end
-      context "on :to" do
-        context "if :clients option is specified" do
-          it "should return all connections if :clients is nil" do
-            find(:to => {:clients => nil}).should eql(@connections)
-          end
-          it "should return none connections if :clients is empty" do
-            find(:to => {:clients => []}).should eql([])
-          end
-          it "should return only connections from specified client" do
-            find(:to => {:clients => "client1"}).should eql([@connection1,@connection2])
-          end
-          it "should return only connections from specified clients if array provided" do
-            find(:to => {:clients => ["client1","client2"]}).should eql([@connection1,@connection2,@connection3])
-          end
-        end
-        context "if :channels option is specified" do
-          it "should return all connections if :channels is nil" do
-            find(:to => {:channels => nil}).should eql(@connections)
-          end
-          it "should return none connections if :channels is empty" do
-            find(:to => {:channels => []}).should eql([])
-          end
-          it "should return all connections that include specified channel" do
-            find(:to => {:channels => "3"}).should eql([@connection2,@connection4])
-          end
-          it "should return all connections that include at last one of specified channels" do
-            find(:to => {:channels => ["2","3"]}).should eql([@connection2,@connection3,@connection4])
-          end
-        end
-        context "if both :clients and :channels options are provided" do
-          context "but :channels are nil" do
-            it "should return only connections from specified client" do
-              find(:to => {:channels => nil,:clients => "client1"}).should eql([@connection1,@connection2])
-            end
-            it "should return only connections from specified clients if array provided" do
-              find(:to => {:channels => nil,:clients => ["client1","client2"]}).should eql([@connection1,@connection2,@connection3])
-            end
-          end
-          context "but :channels are empty" do
-            it "should return none connections" do
-              find(:to => {:channels => [],:clients => "client1"}).should eql([])
-            end
-            it "should return none connections if array provided" do
-              find(:to => {:channels => [],:clients => ["client1","client2"]}).should eql([])
-            end
-          end
-          context "but :clients are nil" do
-            it "should return all connections that include specified channel" do
-              find(:to => {:clients => nil,:channels => "3"}).should eql([@connection2,@connection4])
-            end
-            it "should return all connections that include at last one of specified channels" do
-              find(:to => {:clients => nil,:channels => ["2","3"]}).should eql([@connection2,@connection3,@connection4])
-            end
-          end
-          context "but :clients are empty" do
-            it "should return none connections" do
-              find(:to => {:clients => [],:channels => "3"}).should eql([])
-            end
-            it "should return none connections if array provided" do
-              find(:to => {:clients => [],:channels => ["2","3"]}).should eql([])
-            end
-          end
-          it "should return only connections from specified client that include specified channel" do
-            find(:to => {:clients => "client1",:channels => "3"}).should eql([@connection2])
-            find(:to => {:clients => "client1",:channels => "2"}).should eql([])
-          end
-          it "should return only connections from specified client that include one of specified channels" do
-            find(:to => {:clients => "client1",:channels => ["2","3"]}).should eql([@connection2])
-          end
-          it "should return only connections from specified clients that include specified channel" do
-            find(:to => {:clients => ["client1","client2"],:channels => "2"}).should eql([@connection3])
-          end
-          it "should return only connections from specified clients that include at last one of specified channels" do
-            find(:to => {:clients => ["client1","client2"],:channels => ["2","1"]}).should eql([@connection2,@connection3])
-          end
-        end
-      end
-      
-      context "on :except" do
-        context "if :clients option is specified" do
-          it "should return all connections if :clients is nil" do
-            find(:except => {:clients => nil}).should eql(@connections)
-          end
-          it "should return all connections if :clients is empty" do
-            find(:except => {:clients => []}).should eql(@connections)
-          end
-          it "should return all connections except of specified client" do
-            find(:except => {:clients => "client1"}).should eql([@connection3,@connection4])
-          end
-          it "should return all connections except of specified clients if array provided" do
-            find(:except => {:clients => ["client1","client2"]}).should eql([@connection4])
-          end
-        end
-        context "if :channels option is specified" do
-          it "should return all connections if :channels is nil" do
-            find(:except => {:channels => nil}).should eql(@connections)
-          end
-          it "should return all connections if :channels is empty" do
-            find(:except => {:channels => []}).should eql(@connections)
-          end
-          it "should return all connections except of that include all specified channels" do
-            find(:except => {:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
-          end
-        end
-        context "if both :clients and :channels options are provided" do
-          context "but :channels are nil" do
-            it "should return all connections except of specified client" do
-              find(:except => {:channels => nil,:clients => "client1"}).should eql([@connection3,@connection4])
-            end
-            it "should return all connections except of specified clients if array provided" do
-              find(:except => {:channels => nil,:clients => ["client1","client2"]}).should eql([@connection4])
-            end
-          end
-          context "but :channels are empty" do
-            it "should return all connections except of specified client" do
-              find(:except => {:channels => [],:clients => "client1"}).should eql([@connection3,@connection4])
-            end
-            it "should return all connections except of provided clients if array provided" do
-              find(:except => {:channels => [],:clients => ["client1","client2"]}).should eql([@connection4])
-            end
-          end
-          context "but :clients are nil" do
-            it "should return all connections except of that include all of specified channels" do
-              find(:except => {:clients => nil,:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
-            end
-          end
-          context "but :clients are empty" do
-            it "should return all connections except of that include all of specified channels " do
-              find(:except => {:clients => [],:channels => ["2","5"]}).should eql([@connection1,@connection2,@connection4])
-            end
-          end
-          it "should return all connections except of specified client or all specified channels" do
-            find(:except => {:clients => "client2",:channels => "3"}).should eql([@connection1,@connection2,@connection4])
-            find(:except => {:clients => "client2",:channels => ["3","5"]}).should eql([@connection1,@connection2])
-          end
-          it "should return only connections from specified clients that include specified channel" do
-            find(:except => {:clients => ["client1","client2"],:channels => "3"}).should eql([@connection4])
-            find(:except => {:clients => ["client1","client2"],:channels => ["3","5"]}).should eql([])
-          end
-        end
-      end
-    
-      context "on :to and :except" do
-        context "should value 'except' more that 'to'" do
-          it "on :client" do
-            find(:to => {:clients => "client1"},:except => {:clients => "client1"}).should eql([])
-          end
-          it "on :channels" do
-            find(:to => {:channels => "5"},:except => {:channels => "5"}).should eql([])
-          end
-          it "on :client allow and :channels except" do
-            find(:to => {:clients => "client2"},:except => {:channels => ["2","5"]}).should eql([])
-          end
-          it "on :channels allow and :clients except" do
-            find(:to => {:channels => ["5"]},:except => {:clients => "client2"}).should eql([@connection2,@connection4])
-          end
-        end
-      end
-    end
-    
-  end
-end

data/spec/socky/connection_spec.rb

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