socky 0.2.1 → 0.4.0

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

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