socky 0.0.7 → 0.0.8

data/lib/socky/options/parser.rb

@@ -1,58 +1,68 @@
+require 'optparse'
+
 module Socky
-  module Options
-    module Parser
+  class Options
+    class Parser
 
-      def parse_options(argv)
-        OptionParser.new do |opts|
-          opts.summary_width = 25
-          opts.banner = "Usage: socky [options]\n"
+      class << self
+        def parse(argv)
+          result = {}
+          opts = OptionParser.new do |opts|
+            opts.summary_width = 25
+            opts.banner = "Usage: socky [options]\n"
 
-          opts.separator ""
-          opts.separator "Configuration:"
+            opts.separator ""
+            opts.separator "Configuration:"
 
-          opts.on("-g", "--generate FILE", String, "Generate config file") do |v|
-            options[:config_path] = File.expand_path(v) if v
-            generate_config_file
-          end
+            opts.on("-g", "--generate FILE", String, "Generate config file") do |path|
+              result[:config_path] = File.expand_path(path) if path
+              Config.generate(result[:config_path])
+            end
 
-          opts.on("-c", "--config FILE", String, "Path to configuration file.", "(default: #{Socky.config_path})") do |v|
-            options[:config_path] = File.expand_path(v)
-          end
+            opts.on("-c", "--config FILE", String, "Path to configuration file.", "(default: #{Socky.config_path})") do |path|
+              result[:config_path] = File.expand_path(path)
+            end
 
-          opts.separator ""; opts.separator "Network:"
+            opts.separator ""; opts.separator "Network:"
 
-          opts.on("-p", "--port PORT", Integer, "Specify port", "(default: 8080)") do |v|
-            options[:port] = v
-          end
+            opts.on("-p", "--port PORT", Integer, "Specify port", "(default: 8080)") do |port|
+              result[:port] = port
+            end
 
-          opts.separator ""; opts.separator "Logging:"
+            opts.separator ""; opts.separator "Logging:"
 
-          opts.on("-l", "--log FILE", String, "Path to print debugging information.", "(default: #{Socky.log_path})") do |v|
-            options[:log_path] = File.expand_path(v)
-          end
+            opts.on("-l", "--log FILE", String, "Path to print debugging information.", "(default: #{Socky.log_path})") do |path|
+              result[:log_path] = File.expand_path(path)
+            end
 
-          opts.on("--debug", "Run in debug mode") do
-            options[:debug] = true
-          end
+            opts.on("--debug", "Run in debug mode") do
+              result[:debug] = true
+            end
 
-          opts.on("--deep-debug", "Run in debug mode that is even more verbose") do
-            options[:debug] = true
-            options[:deep_debug] = true
-          end
+            opts.on("--deep-debug", "Run in debug mode that is even more verbose") do
+              result[:debug] = true
+              result[:deep_debug] = true
+            end
 
-          opts.separator ""; opts.separator "Miscellaneous:"
+            opts.separator ""; opts.separator "Miscellaneous:"
 
-          opts.on_tail("-?", "--help", "Display this usage information.") do
-            puts "#{opts}\n"
-            exit
-          end
+            opts.on_tail("-?", "--help", "Display this usage information.") do
+              puts "#{opts}\n"
+              exit
+            end
 
-          opts.on_tail("-v", "--version", "Display version") do |v|
-            puts "Socky #{VERSION}"
-            exit
+            opts.on_tail("-v", "--version", "Display version") do
+              puts "Socky #{VERSION}"
+              exit
+            end
           end
-        end.parse!(argv)
-        options
+          opts.parse!(argv)
+          result
+        rescue OptionParser::InvalidOption => error
+          puts "#{opts}\n"
+          puts error.message
+          exit
+        end
       end
 
     end

data/lib/socky/runner.rb

@@ -1,17 +1,16 @@
 module Socky
   class Runner
     include Socky::Misc
-    include Socky::Options
 
     class << self
       def run(argv = ARGV)
-        self.new(argv)
+        server = self.new(argv)
+        server.start
       end
     end
 
     def initialize(argv = ARGV)
-      prepare_options(argv)
-      start
+      Options.prepare(argv)
     end
 
     def start

data/lib/socky/server.rb

@@ -20,7 +20,7 @@ module Socky
       end
 
       def send_data(message, connections)
-        connections.each{|c| c.send_message message}
+        connections.each{|connection| connection.send_message message}
       end
 
     end

data/spec/em-websocket_spec.rb

@@ -0,0 +1,37 @@
+require 'spec/spec_helper'
+
+describe EM::WebSocket::Connection do
+
+  it "should not receive debug message if :debug option is false" do
+    Socky.logger.stub!(:debug)
+    Socky.logger.should_not_receive(:debug)
+    EM.run do
+      EM.add_timer(0.1) do
+        http = EventMachine::HttpRequest.new('ws://127.0.0.1:9999/').get(:timeout => 0)
+        http.errback  { http.close_connection }
+        http.callback { http.close_connection }
+      end
+
+      EM::WebSocket.start(:host => "127.0.0.1", :port => 9999, :debug => false) do |ws|
+        ws.onclose { EM.stop }
+      end
+    end
+  end
+
+  it "should use Socky.logger.debug instead of pp when instance call #debug" do
+    Socky.logger.stub!(:debug)
+    Socky.logger.should_receive(:debug).with("Socket initialize")
+    EM.run do
+      EM.add_timer(0.1) do
+        http = EventMachine::HttpRequest.new('ws://127.0.0.1:9999/').get(:timeout => 0)
+        http.errback  { http.close_connection }
+        http.callback { http.close_connection }
+      end
+
+      EM::WebSocket.start(:host => "127.0.0.1", :port => 9999, :debug => true) do |ws|
+        ws.onclose { EM.stop }
+      end
+    end
+  end
+
+end

data/spec/files/default.yml

@@ -0,0 +1,7 @@
+:port: 8080
+:debug: false
+
+:subscribe_url: http://localhost:3000/socky/subscribe
+:unsubscribe_url: http://localhost:3000/socky/unsubscribe
+
+:secret: my_secret_key

data/spec/files/invalid.yml

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

data/spec/socky/connection/authentication_spec.rb

@@ -0,0 +1,162 @@
+require 'spec/spec_helper'
+
+describe Socky::Connection::Authentication do
+  include Socky::Connection::Authentication
+  
+  context "instance" do
+    context "#subscribe_request" do
+      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
+        stub!(:authenticated?).and_return(false)
+        stub!(:send_subscribe_request).and_yield(true)
+        should_receive(:add_to_pool)
+        subscribe_request
+      end
+      it "should be authenticated by url if #send_subscribe_request block is true" 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
+      end
+      it "should disconnect if #send_subscribe_request block is false" do
+        stub!(:admin).and_return(false)
+        stub!(:send_subscribe_request).and_yield(false)
+        should_receive(:disconnect)
+        subscribe_request
+      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 admin" do
+        stub!(:admin).and_return(true)
+        authenticate_as_admin.should be_true
+      end
+      it "should return false if not admin" do
+        stub!(:admin).and_return(false)
+        authenticate_as_admin.should be_false
+      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

@@ -0,0 +1,96 @@
+require 'spec/spec_helper'
+
+describe Socky::Connection::Finders do
+  include Socky::Connection::Finders
+  
+  context "class" do
+    before(:each) do
+      @connection1 = mock(:connection1, :client => "client1", :channels => [])
+      @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
+      self.class.find_all.should eql(@connections)
+    end
+    context "#find" do
+      it "should return all connections if no options specified" do
+        self.class.find.should eql(@connections)
+      end
+      context "if :clients option is specified" do
+        it "should return all connections if :clients is nil or empty" do
+          self.class.find(:clients => nil).should eql(@connections)
+          self.class.find(:clients => []).should eql(@connections)
+        end
+        it "should return only connections from specified client" do
+          self.class.find(:clients => "client1").should eql([@connection1,@connection2])
+        end
+        it "should return only connections from specified clients if array provided" do
+          self.class.find(: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 or empty" do
+          self.class.find(:channels => nil).should eql(@connections)
+          self.class.find(:channels => []).should eql(@connections)
+        end
+        it "should return all connections that include specified channel" do
+          self.class.find(:channels => "3").should eql([@connection2,@connection4])
+        end
+        it "should return all connections that include at last one of specified channels" do
+          self.class.find(:channels => ["2","3"]).should eql([@connection2,@connection3,@connection4])
+        end
+      end
+      context "if both :clients and :channels options are provided" do
+        context "but :channels are empty" do
+          it "should return only connections from specified client" do
+            self.class.find(:channels => [],:clients => "client1").should eql([@connection1,@connection2])
+          end
+          it "should return only connections from specified clients if array provided" do
+            self.class.find(:channels => [],:clients => ["client1","client2"]).should eql([@connection1,@connection2,@connection3])
+          end
+        end
+        context "but :clients are empty" do
+          it "should return all connections that include specified channel" do
+            self.class.find(:clients => [],:channels => "3").should eql([@connection2,@connection4])
+          end
+          it "should return all connections that include at last one of specified channels" do
+            self.class.find(:clients => [],:channels => ["2","3"]).should eql([@connection2,@connection3,@connection4])
+          end
+        end
+        it "should return only connections from specified client that include specified channel" do
+          self.class.find(:clients => "client1",:channels => "3").should eql([@connection2])
+          self.class.find(:clients => "client1",:channels => "2").should eql([])
+        end
+        it "should return only connections from specified client that include one of specified channels" do
+          self.class.find(:clients => "client1",:channels => ["2","3"]).should eql([@connection2])
+        end
+        it "should return only connections from specified clients that include specified channel" do
+          self.class.find(: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
+          self.class.find(:clients => ["client1","client2"],:channels => ["2","1"]).should eql([@connection2,@connection3])
+        end
+      end
+    end
+    it "#find_by_clients should call #find with clients option" do
+      self.class.should_receive(:find).with({:clients => "client1"})
+      self.class.find_by_clients("client1")
+    end
+    it "#find_by_channels should call #find with channels option" do
+      self.class.should_receive(:find).with({:channels => "1"})
+      self.class.find_by_channels("1")
+    end
+    it "#find_by_clients_and_channels should call #find with both clients and channels option" do
+      self.class.should_receive(:find).with({:clients => "client1", :channels => "1"})
+      self.class.find_by_clients_and_channels("client1","1")
+    end
+    
+  end
+end