rocket-server 0.0.1

data/spec/connection_spec.rb

@@ -0,0 +1,257 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+class Rocket::Server::Connection
+  def send(*args); end  
+end
+
+describe Rocket::Server::Connection do
+  subject do
+    Rocket::Server::Connection
+  end
+
+  before do
+    Rocket::Server.instance_variable_set("@apps", {"test-app" => {"secret" => "my-secret"}})
+  end
+  
+  describe "#initialize" do
+    it "should set all callbacks" do
+      conn = subject.new({})
+      conn.instance_variable_get("@onopen").should == conn.method(:onopen)
+      conn.instance_variable_get("@onclose").should == conn.method(:onclose)
+      conn.instance_variable_get("@onerror").should == conn.method(:onerror)
+      conn.instance_variable_get("@onmessage").should == conn.method(:onmessage)
+    end
+  end
+  
+  describe "#onopen" do
+    context "when valid app specified in request" do
+      before do
+        @conn = subject.new(1)
+        @conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+        @conn.request.stubs(:"[]").with("Query").returns({})
+      end
+      
+      it "should start new session for it" do
+        @conn.stubs(:send)
+        @conn.onopen
+        session = @conn.session
+        session.should be_kind_of(Rocket::Server::Session)
+        session.app_id.should == "test-app"
+      end
+      
+      it "should send message to connected client" do
+        @conn.expects(:send).with({:event => "rocket:connected", :data => { :session_id => 1 }}.to_json)
+        @conn.onopen.should == true
+      end
+    end
+    
+    context "when invalid app specified in request" do
+      it "should close connection with client" do
+        conn = subject.new(1)
+        conn.request.expects(:"[]").with("Path").returns("/app/non-existing-app")
+        conn.request.stubs(:"[]").with("Query").returns({})
+        conn.expects(:close_connection)
+        conn.onopen
+      end
+    end
+    
+    context "when valid secret given in request query" do
+      it "should start new session and authenticate it" do
+        conn = subject.new(1)
+        conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+        conn.request.stubs(:"[]").with("Query").returns("secret" => "my-secret")
+        conn.expects(:send).with({:event => "rocket:connected", :data => { :session_id => 1 }}.to_json)
+        conn.onopen
+        session = conn.session
+        session.should be_authenticated
+      end
+    end
+    
+    context "when invalid or no secret given" do
+      it "shouldn't authenticate session" do
+        conn = subject.new(1)
+        conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+        conn.request.stubs(:"[]").with("Query").returns("secret" => "fooobar")
+        conn.onopen
+        session = conn.session
+        session.should_not be_authenticated
+      end
+    end
+  end
+  
+  describe "#onclose" do
+    context "when session is active" do
+      it "should close it" do
+        conn = subject.new(1)
+        conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+        conn.request.stubs(:"[]").with("Query").returns({})
+        conn.onopen
+        conn.session.expects(:close)
+        conn.onclose
+      end
+    end
+    
+    context "when session is not active" do
+      it "should do nothing" do
+        conn = subject.new(1)
+        conn.onclose.should be_nil
+      end
+    end
+  end
+  
+  describe "#onerror" do
+    it "should log given error" do
+      conn = Rocket::Server::Connection.new(1)
+      conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+      conn.request.stubs(:"[]").with("Query").returns({})
+      conn.onopen
+      conn.onerror("test error here")
+    end
+  end
+  
+  describe "#onmessage" do
+    subject do 
+      conn = Rocket::Server::Connection.new(1)
+      conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+      conn.request.stubs(:"[]").with("Query").returns({})
+      conn.onopen
+      conn
+    end
+  
+    context "when given message is valid JSON" do
+      context "for rocket:subscribe message" do
+        it "should process it" do
+          conn = subject
+          message = {"event" => "rocket:subscribe", "channel" => "my-test-one"}
+          conn.expects(:subscribe!).with(instance_of(Hash))
+          conn.onmessage(message.to_json)
+        end
+      end
+      
+      context "for rocket:unsubscribe message" do
+        it "should process it" do
+          conn = subject
+          message = {"event" => "rocket:unsubscribe", "channel" => "my-test-one"}
+          conn.expects(:unsubscribe!).with(instance_of(Hash))
+          conn.onmessage(message.to_json)
+        end
+      end
+      
+      context "for other message" do
+        it "should process it" do
+          conn = subject
+          message = {"channel" => "my-test-chan", "event" => "my-test-even", "data" => {"foo" => "bar"}}
+          conn.expects(:trigger!).with(instance_of(Hash))
+          conn.onmessage(message.to_json)
+        end
+      end
+    end
+    
+    context "when given message is invalid JSON" do
+      it "should log proper error" do
+        conn = subject
+        conn.onmessage("{invalid JSON here}")
+      end
+    end
+  end
+  
+  describe "#session?" do
+    context "when current session exists" do
+      it "should be true" do
+        conn = subject.new(1)
+        conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+        conn.request.stubs(:"[]").with("Query").returns({})
+        conn.onopen
+        conn.should be_session
+      end
+    end
+    
+    context "when there is no session" do
+      it "should be false" do
+        conn = subject.new(1)
+        conn.should_not be_session   
+      end
+    end
+  end
+  
+  describe "#subscribe!" do
+    before do
+      @conn = subject.new(1)
+      @conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+      @conn.request.stubs(:"[]").with("Query").returns({})
+      @conn.onopen
+    end
+    
+    context "when given valid event data" do
+      it "should subscribe channel" do
+        @conn.subscribe!({"channel" => "test-channel"}).should be
+        @conn.session.subscriptions.should have(1).item
+      end
+    end
+    
+    context "when no valid event data given" do
+      it "should return false" do
+        @conn.subscribe!({"channello" => "test-channel"}).should be_false
+      end
+    end
+  end
+  
+  describe "#unsubscribe!" do
+    before do
+      @conn = subject.new(1)
+      @conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+      @conn.request.stubs(:"[]").with("Query").returns({})
+      @conn.onopen
+    end
+    
+    context "when given valid event data" do
+      it "should unsubscribe channel" do
+        @conn.unsubscribe!({"channel" => "test-channel"}) 
+      end
+    end
+    
+    context "when no valid event data given" do
+      it "should return false" do
+        @conn.unsubscribe!({"channello" => "test-channel"}).should be_false
+      end
+    end
+  end
+  
+  describe "#trigger!" do
+    before do 
+      @conn = subject.new(1)
+      @conn.request.expects(:"[]").with("Path").returns("/app/test-app")
+      @conn.request.stubs(:"[]").with("Query").returns({})
+      @conn.onopen
+    end
+    
+    context "when session is not authenticated" do
+      it "should log proper error" do
+        data = {"event" => "test", "channel" => "testing"}
+        @conn.trigger!(data)
+      end
+    end
+    
+    context "when session is authenticated" do
+      before do
+        @conn.session.authenticate!("my-secret")
+      end
+      
+      context "when event data is valid" do
+        it "should broadcast it on given channel" do
+          data = {"event" => "test", "channel" => "testing"}
+          Rocket::Server::Channel["test-app" => "testing"].expects(:push).with(data.to_json)
+          @conn.trigger!(data)
+        end
+      end
+      
+      context "when event data is invalid" do
+        it "should log proper error" do
+          data = {"evento" => "test", "channello" => "testing"}
+          @conn.trigger!(data)
+        end
+      end
+    end
+    
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+class HelpersPoweredClass
+  include Rocket::Server::Helpers
+end
+
+describe Rocket::Server::Helpers do
+  subject do
+    HelpersPoweredClass.new
+  end
+  
+  it "#log should be proxy to Rocket::Server.logger" do
+    subject.log.should == Rocket::Server.logger
+  end
+  
+  it "should respond to all log level-specific methods" do
+    subject.should respond_to(:log_info)
+    subject.should respond_to(:log_debug)
+    subject.should respond_to(:log_warn)
+    subject.should respond_to(:log_error)
+    subject.should respond_to(:log_fatal)
+  end
+end

data/spec/misc_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Rocket::Server::Misc do
+  subject do
+    Rocket::Server::Misc
+  end
+  
+  describe ".generate_config_file" do
+    context "when everything's ok" do
+      it "should create default config under given path" do
+        begin
+          subject.generate_config_file(fname = File.expand_path("../rocket.yml", __FILE__))
+          File.should be_exist(fname)
+          expect { YAML.load_file(fname) }.to_not raise_error 
+        ensure
+          FileUtils.rm_rf(fname)
+        end
+      end
+    end
+    
+    context "when error raised" do
+      it "should rescue it and display, and exit program" do
+        out, err = capture_output {
+          File.expects(:open).raises(Errno::EACCES) 
+          expect { subject.generate_config_file("rocket.yml") }.to raise_error(SystemExit)
+        }
+        out.should == "Permission denied\n"
+      end
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,138 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Rocket::Server::Runner do
+  subject do
+    Rocket::Server::Runner
+  end
+  
+  describe "#initialize" do
+    it "should set options" do
+      subject.new(1=>2).options.should == {1=>2}
+    end
+    
+    context "when host and port given" do
+      it "should set it properly" do
+        serv = subject.new(:host => 'test.host', :port => 999)
+        serv.host.should == 'test.host'
+        serv.port.should == 999
+      end
+    end
+    
+    context "when no host or port given" do
+      it "should set default values for it" do
+        serv = subject.new
+        serv.host.should == 'localhost'
+        serv.port.should == 9772
+      end
+    end
+    
+    it "should remove unnecessary options" do
+      serv = subject.new(:verbose => true, :quiet => false, :log => 1, :apps => [], :plugins => [])
+      serv.options.values.should be_empty
+    end
+    
+    context "when :pid option given" do
+      it "should set it" do
+        serv = subject.new(:pid => "test.pid")
+        serv.pidfile.should == "test.pid"
+      end
+    end
+    
+    context "when :daemon option given" do
+      it "should set it" do
+        serv = subject.new(:daemon => true)
+        serv.daemon.should == true
+      end
+    end
+  end
+  
+  describe "#stop!" do
+    it "should stop EventMachine reactor" do
+      EM.expects(:stop)
+      subject.new.stop!
+    end
+  end
+  
+  describe "#start!" do
+    context "when daemon mode disabled" do
+      it "should start server on given host and port" do
+        EM.expects(:start_server).with("test.host", 9992, Rocket::Server::Connection, instance_of(Hash))
+        t = Thread.new { subject.new(:host => "test.host", :port => 9992).start! }
+        t.kill
+      end
+    end
+    
+    context "when daemon mode enabled" do
+      it "should daemonize server" do
+        serv = subject.new(:host => "test.host", :port => 9992, :daemon => true)
+        serv.expects(:daemonize!).returns(:test)
+        serv.start!.should == :test
+      end
+    end
+  end
+  
+  describe "#save_pid" do
+    context "when pid file given" do
+      subject do
+        Rocket::Server::Runner.new(:pid => "test.pid")
+      end
+      
+      context "and everything's ok" do
+        it "should save process id to this file" do
+          mock_file = mock
+          mock_file.expects(:write).with("#{Process.pid}\n")
+          File.expects(:open).with("test.pid", "w+").yields(mock_file)
+          subject.save_pid
+        end
+      end
+      
+      context "and some errors raises" do
+        it "should display error and quit" do
+          out, err = capture_output {
+            FileUtils.expects(:mkdir_p).with(".").raises(Errno::EACCES)
+            expect { subject.save_pid }.to raise_error(SystemExit)
+          }
+          out.should == "Permission denied\n"
+        end
+      end
+    end
+  end
+  
+  describe "#kill!" do
+    context "when pid file given" do
+      subject do
+        Rocket::Server::Runner.new(:pid => "test.pid")
+      end
+      
+      context "and it doesn't exist" do
+        it "should do nothing" do
+          File.expects(:exists?).with("test.pid").returns(false)
+          subject.kill!.should_not be
+        end
+      end
+      
+      context "and it exists" do
+        it "should remove it and kill given process" do
+          File.expects(:exists?).with("test.pid").returns(true)
+          File.expects(:read).with("test.pid").returns("123\n")
+          FileUtils.expects(:rm).with("test.pid")
+          Process.expects(:kill).with(9, 123)
+          subject.kill!.should == 123
+        end
+      end
+    end
+  end
+  
+  describe "#daemonize!" do
+    subject do
+      Rocket::Server::Runner.new(:pid => "test.pid")
+    end
+    
+    it "should switch to deamon mode and start server" do
+      serv = subject
+      serv.expects(:daemonize)
+      serv.expects(:start!)
+      serv.daemonize!
+    end
+  end
+end