em-campfire 0.0.1 → 1.0.0

data/spec/lib/messages_spec.rb

@@ -1,47 +1,58 @@
-require "spec_helper"
+require "messages_helper"
+
+class MessageTester < ModuleHarness
+  include EventMachine::Campfire::Messages
+  include EventMachine::Campfire::Rooms
+end
 
 describe EventMachine::Campfire::Messages do
-    
-  before :each do   
-    stub_rooms_data_request
-    stub_join_room_request(123)
-    stub_stream_room_request(123)
-    EM.run_block { @adaptor = a(EM::Campfire) }
+  before :each do
+    @adaptor = MessageTester.new
   end
+  
+  describe "posting messages" do
+    it "should say" do
+      @adaptor.expects(:send_message).with(123, "foo", "TextMessage")
+      @adaptor.say("foo", 123)
+    end
 
-  it "should say a message" do
-    mock_logger
-    stub = stub_message_post_request
-    
-    EM.run_block {
-      @adaptor.join 123
-      @adaptor.say "Hi", 123
-    }
-    stub.should have_been_requested
-    logger_output.should =~ /DEBUG.*Posted Textmessage "Hi" to room 123/
+    it "should paste" do
+      @adaptor.expects(:send_message).with(123, "foo", "PasteMessage")
+      @adaptor.paste("foo", 123)
+    end
+
+    it "should play" do
+      @adaptor.expects(:send_message).with(123, "foo", "SoundMessage")
+      @adaptor.play("foo", 123)
+    end
   end
 
-  it "should paste a message" do
-    mock_logger
-    stub = stub_message_post_request
-   
-    EM.run_block {
-      @adaptor.join 123
-      @adaptor.paste "Hi", 123
-    }
-    stub.should have_been_requested
-    logger_output.should =~ /DEBUG.*Posted PasteMessage "Hi" to room 123/
+  it "should not try to post a message to a room it hasn't joined" do
+    mock_logger(MessageTester)
+    EM.run_block { @adaptor.say "Hi", 123 }
+
+    logger_output.should =~ %r{Couldn't post message "Hi" to room 123 as no rooms have been joined}
   end
-    
-  it "should play a sound" do
-    mock_logger
-    stub = stub_message_post_request
-   
-    EM.run_block {
-      @adaptor.join 123
-      @adaptor.play "nyan", 123
-    }
-    stub.should have_been_requested
-    logger_output.should =~ /DEBUG.*Posted SoundMessage "nyan" to room 123/
+
+  context "having successfully joined a room" do
+    before :each do
+      mock_logger(MessageTester)
+      stub_join_room_request(123)
+      EM.run_block { @adaptor.join(123) }
+    end
+
+    it "should say a message" do
+      stub = stub_message_post_request
+      EM.run_block { @adaptor.say("Hi", 123) }
+      stub.should have_been_requested
+      logger_output.should =~ /DEBUG.*Posted TextMessage "Hi" to room 123/
+    end
+
+    it "should handle message posting failure" do
+      stub = stub_message_post_request(500)
+      EM.run_block { @adaptor.say("Hi", 123) }
+      stub.should have_been_requested
+      logger_output.should =~ %r{ERROR.*Couldn't post message "Hi" to room 123 using url https://oxygen.campfirenow.com/room/123/speak.json, http response from the API was 500}
+    end
   end
 end

data/spec/lib/rooms_spec.rb

@@ -1,47 +1,221 @@
-require "spec_helper"
+require "rooms_helper"
+
+class RoomsTestContainer < ModuleHarness
+  include EventMachine::Campfire::Rooms
+
+  def cache; @cache ||= EventMachine::Campfire::Cache.new; end
+  def process_message; end
+end
 
 describe EventMachine::Campfire::Rooms do
-    
   before :each do
-    @message_post_url = "https://#{valid_params[:subdomain]}.campfirenow.com/room/123/speak.json"
-    stub_rooms_data_request
-    EM.run_block { @adaptor = a(EM::Campfire) }
+    mock_logger(RoomsTestContainer)
+    @adaptor = RoomsTestContainer.new
   end
 
-  context "#join" do
-    before :each do
-      EM.run_block { @adaptor = a EM::Campfire }
-    end
-      
+  describe "#join" do
     it "should allow joining by id" do
-      mock_logger
-        
       join_stub = stub_join_room_request(123)
-      stream_stub = stub_stream_room_request(123)
       EM.run_block { @adaptor.join(123) }
       logger_output.should =~ /INFO.*Joined room 123 successfully/
       join_stub.should have_been_requested
     end
-      
-    it "should allow joining by name" do
+
+    it "should not be able to join an invalid room" do
+      join_stub = stub_join_room_request(9999999, 302)
+      EM.run_block { @adaptor.join(9999999) }
+      logger_output.should =~ /Error joining room: 9999999/
+    end
+
+    it "should call a passed block on success" do
       join_stub = stub_join_room_request(123)
-      stream_stub = stub_stream_room_request(123)
-      EM.run_block { @adaptor.join("foo") }
-      join_stub.should have_been_requested
+      object = mock()
+      object.expects(:ping).with("foo")
+          
+      EM.run_block {
+        @adaptor.join(123) {|room_id| object.ping("foo") }
+      }
     end
-      
-    it "should not be able to join an invalid room" do
-      mock_logger
-      stream_stub = stub_stream_room_request(9999999999999999)
-      url = "https://#{valid_params[:subdomain]}.campfirenow.com/room/9999999999999999/join.json"
-      join_stub = stub_request(:post, url).
-        with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-        to_return(:status => 302, :body => "", :headers => {})
-        
-      EM.run_block { @adaptor.join(9999999999999999) }
-      logger_output.should =~ /Error joining room: 9999999999999999/
-      join_stub.should have_been_requested
-      stream_stub.should_not have_been_requested
+  end
+
+  describe "streaming" do
+    it "should stream a room" do
+      stream_stub = stub_stream_room_request(123, stream_message_json)
+      @adaptor.expects(:process_message).with(stream_message)
+      EM.run_block { @adaptor.stream(123)}
+      stream_stub.should have_been_requested
+      logger_output.should =~ /INFO.*Disconnected from #{stream_url_for_room(123)}/
+    end
+
+    it "should handle invalid json" do
+      invalid_json = "{:one => two}\n"
+      stream_stub = stub_stream_room_request(123, invalid_json)
+      @adaptor.expects(:process_message).never
+      EM.run_block { @adaptor.stream(123)}
+      stream_stub.should have_been_requested
+      logger_output.should =~ /Couldn't parse json data for room 123, data was #{invalid_json}, error was: parse error: invalid object key \(must be a string\)/
+    end
+
+    it "should handle server timeouts" do
+      request = stub_timeout_stream_room_request(123)
+
+      EM.run_block {@adaptor.stream(123)}
+      logger_output.should =~ /ERROR.*Couldn't stream room 123 at url #{stream_url_for_room(123)}, error was WebMock timeout error/
+    end
+
+    it "should re-connect to a streaming URL when timed out" do
+      request = stub_timeout_stream_room_request(123)
+
+      EM.run_block {@adaptor.stream(123)}
+      request.should have_been_requested.twice
+      logger_output.should =~ /ERROR.*Couldn't stream room 123 at url #{stream_url_for_room(123)}, error was WebMock timeout error/
+    end
+
+    it "should handle server errors streaming data" do
+      request = stub_stream_room_request(123, "", 500)
+
+      EM.run_block {@adaptor.stream(123)}
+      request.should have_been_requested
+      logger_output.should =~ /ERROR.*Couldn't stream room with url #{stream_url_for_room(123)}, http response from API was 500/
+    end
+
+    it "should re-connect to a streaming URL when disconnected" do
+      stream_stub = stub_stream_room_request(123, "")
+      EM.run {
+        @adaptor.stream(123)
+        # Re-connecting takes two ticks
+        EM.next_tick { EM.next_tick {EM.stop} }
+      }
+      logger_output.should =~ /INFO.*Disconnected from #{stream_url_for_room(123)}/
+      stream_stub.should have_been_requested.twice
+    end
+  end
+  
+  describe "fetching metadata" do
+    describe "for individual rooms" do
+      it "should fetch room data" do
+        request = stub_room_data_request(123)
+        yielded_data = nil
+
+        EM.run_block {
+          @adaptor.room_data_from_room_id(123) {|data| yielded_data = data}
+        }
+
+        yielded_data.should eql(valid_room_cache_data[123])
+        request.should have_been_requested
+        logger_output.should =~ /DEBUG.*Fetched room data for 123 \(#{valid_room_cache_data[123]['name']}\)/
+      end
+
+      it "should handle server errors fetching data" do
+        request = stub_room_data_request(123, 500)
+
+        EM.run_block {@adaptor.room_data_from_room_id(123)}
+        request.should have_been_requested
+        logger_output.should =~ /ERROR.*Couldn't fetch room data with url #{room_data_url(123)}, http response from API was 500/
+      end
+
+
+      it "should handle server timeouts" do
+        request = stub_timeout_room_data_request(123)
+
+        EM.run_block {@adaptor.room_data_from_room_id(123)}
+        request.should have_been_requested
+        logger_output.should =~ /ERROR.*Couldn't connect to url #{room_data_url(123)} to fetch room data/
+      end
+
+      it "should not update the room data cache when room data is fresh" do
+        request = stub_room_data_request(123, 304)
+        room_data = valid_room_cache_data[123]
+        room_data_with_etag = room_data.merge({'etag' => etag_for_data(room_data)})
+        @adaptor.cache.expects(:get).with("room-data-123").returns(room_data_with_etag)
+        @adaptor.cache.expects(:set).never
+
+        EM.run_block { @adaptor.room_data_from_room_id(123) }
+        logger_output.should =~ /DEBUG.*HTTP response was 304, serving room data for room 123 \(#{room_data['name']}\) from cache/
+      end
+
+      it "should update the room data cache when room data is stale" do
+        request = stub_room_data_request(123)
+        room_data = valid_room_cache_data[123]
+        room_data_with_etag = room_data.merge({'etag' => etag_for_data(valid_room_cache_data[123])})
+        @adaptor.cache.expects(:get).with("room-data-123").returns(valid_room_cache_data[123].merge({'etag' => etag_for_data("no such etag")}))
+        @adaptor.cache.expects(:set).with("room-data-123", valid_room_cache_data[123].merge({'etag' => etag_for_data(room_data)}))
+
+        EM.run_block { @adaptor.room_data_from_room_id(123) }
+      end
+    end
+
+    describe "for all rooms" do
+      before :each do
+        @cache_response = {'etag' => etag_for_room_list_data, 'data' => room_list_data_api_response['rooms']}
+        @adaptor.cache.expects(:get).with("room-list-data").returns(@cache_response)
+      end
+
+      it "should fetch a room list" do
+        request = stub_room_list_data_request
+        rooms_data = room_list_data_api_response
+        rooms_data_with_etag = rooms_data.merge({'etag' => etag_for_data(rooms_data)})
+
+        yielded_data = nil
+
+        EM.run_block {
+          @adaptor.room_data_for_all_rooms {|data| yielded_data = data}
+        }
+
+        yielded_data.should eql(room_list_data_api_response['rooms'])
+
+        request.should have_been_requested
+        logger_output.should =~ /DEBUG.*Fetched room data for all rooms/
+      end
+
+      it "should handle server errors fetching data" do
+        request = stub_room_list_data_request(500)
+
+        EM.run_block {@adaptor.room_data_for_all_rooms}
+
+        request.should have_been_requested
+        logger_output.should =~ /ERROR.*Couldn't fetch room list with url #{rooms_data_url}, http response from API was 500/
+      end
+
+      it "should handle server timeouts" do
+        request = stub_timeout_room_list_data_request
+
+        EM.run_block {@adaptor.room_data_for_all_rooms}
+        request.should have_been_requested
+
+        logger_output.should =~ /ERROR.*Error processing url #{rooms_data_url} to fetch room data: WebMock timeout error/
+      end
+
+      describe "when the cached data is fresh" do
+        before :each do
+          stub_room_list_data_request(304)
+          rooms_data = room_list_data_api_response
+          @rooms_data_with_etag = rooms_data.merge({'etag' => etag_for_room_list_data})
+        end
+
+        it "should not update the cached room list" do
+          @adaptor.cache.expects(:set).never
+
+          EM.run_block { @adaptor.room_data_for_all_rooms }
+        end
+
+        it "should serve cached data" do
+          yielded_data = nil
+
+          EM.run_block {
+            @adaptor.room_data_for_all_rooms { |data| yielded_data = data }
+          }
+
+          logger_output.should =~ /DEBUG.*HTTP response was 304, serving room list data from cache/
+          yielded_data.should eql(@cache_response)
+        end
+      end
+
+      it "should update the room list data cache when room data is stale" do
+        stub_room_list_data_request
+        @adaptor.cache.expects(:set).with("room-list-data", {'data' => room_list_data_api_response['rooms'], 'etag' => 'new etag'})
+        EM.run_block { @adaptor.room_data_for_all_rooms }
+      end
     end
   end
 end

data/spec/lib/users_spec.rb

@@ -0,0 +1,192 @@
+require "users_helper"
+
+class UsersTestContainer < ModuleHarness
+  include EventMachine::Campfire::Users
+
+  def cache; @cache ||= EventMachine::Campfire::Cache.new; end
+end
+
+describe EventMachine::Campfire::Users do
+  before :each do
+    @adaptor = UsersTestContainer.new
+  end
+
+  describe "#is_me?" do
+    it "should return true if the passed user_id belongs to me" do
+      @adaptor.cache.stubs(:get).with('user-data-me').returns(valid_user_cache_data['me'])
+
+      EM.run_block {
+        @adaptor.is_me?(789).should eql(true)
+      }
+    end
+
+    it "should return false if the passed user_id doesn't belong to me" do
+      @adaptor.cache.stubs(:get).with('user-data-me').returns(valid_user_cache_data['me'])
+
+      EM.run_block {
+        @adaptor.is_me?(123).should eql(false)
+      }
+    end
+
+    it "should use cached data if available" do
+      @adaptor.cache.expects(:get).with('user-data-me').returns(valid_user_cache_data['me'])
+      @adaptor.expects(:fetch_user_data_for_self).never
+      EM.run_block { @adaptor.is_me?(789) }
+    end
+
+    it "should fetch data if no cached data is available" do
+      mock_logger(UsersTestContainer)
+      @adaptor.cache.expects(:get).with('user-data-me').returns(nil)
+      @adaptor.expects(:fetch_user_data_for_self).once.yields(valid_user_cache_data['me'])
+
+      EM.run_block {
+        @adaptor.is_me?(789)
+      }
+      logger_output.should =~ /DEBUG.*No user data cache exists for me, fetching it now/
+    end
+  end
+
+  describe "fetching user data" do
+    before :each do
+      mock_logger(UsersTestContainer)
+    end
+
+    it "should get correct data for a user_id" do
+      stub_user_data_request(123)
+      yielded_data = nil
+      EM.run_block {
+        @adaptor.fetch_user_data_for_user_id(123) do |user_data|
+          yielded_data = user_data
+        end
+      }
+
+      yielded_data["name"].should eql(valid_user_cache_data[123]["name"])
+
+      logger_output.should =~ %r{DEBUG.+Got the user data for 123}
+    end
+
+    it "should handle server errors" do
+      stub_user_data_request(123, 502)
+      EM.run_block {
+        @adaptor.fetch_user_data_for_user_id(123)
+      }
+
+      logger_output.should =~ %r{ERROR.+Couldn't fetch user data for user 123 with url .+, http response from API was 502}
+    end
+
+    it "should handle server timeouts" do
+      stub_timeout_user_data_request(123)
+      EM.run_block {
+        @adaptor.fetch_user_data_for_user_id(123)
+      }
+
+      logger_output.should =~ %r{ERROR.+Couldn't connect to .+ to fetch user data for user 123}
+    end
+
+    describe "when the cache is fresh" do
+      before :each do
+        @user_data = valid_user_cache_data[456]
+      end
+
+      it "should not update the user cache data" do
+        stub_user_data_request(123, 304)
+        @adaptor.cache.expects(:get).with("user-data-123").returns(@user_data)
+        @adaptor.cache.expects(:set).never
+
+        EM.run_block {
+          @adaptor.fetch_user_data_for_user_id(123)
+        }
+      end
+
+      it "should serve cached data" do
+        @adaptor.cache.expects(:get).with("user-data-456").returns(@user_data)
+        stub_user_data_request(456, 304)
+        yielded_data = nil
+
+        EM.run_block {
+          @adaptor.fetch_user_data_for_user_id(456) { |data| yielded_data = data }
+        }
+
+        logger_output.should =~ %r{DEBUG.+HTTP response was 304, serving user data for user 456 \(#{@user_data['name']}\) from cache}
+        yielded_data.should eql(@user_data)
+      end
+    end
+
+    it "should update the user data cache when user data is stale" do
+      user_data = valid_user_cache_data[123]
+      user_data_with_etag = user_data.merge({"etag" => etag_for_data(user_data)})
+      stub_user_data_request(123)
+      @adaptor.cache.expects(:get).with("user-data-123").returns(user_data)
+      @adaptor.cache.expects(:set).with("user-data-123", user_data_with_etag)
+
+      EM.run_block {
+        @adaptor.fetch_user_data_for_user_id(123)
+      }
+    end
+
+    describe "about self" do
+      it "should get correct data for self" do
+        stub = stub_self_data_request
+        yielded_data = nil
+        EM.run_block {
+          @adaptor.fetch_user_data_for_self {|data| yielded_data = data }
+        }
+        stub.should have_been_requested
+        yielded_data.should eql(valid_user_cache_data['me'])
+        # FIXME: Can't work out why these debug messages get dumped to the terminal when others don't
+        logger_output.should =~ /DEBUG.+Got the user data for self/
+      end
+
+      it "should handle server errors" do
+        stub_self_data_request(502)
+        EM.run_block { @adaptor.fetch_user_data_for_self }
+
+        logger_output.should =~ %r{ERROR.+Couldn't fetch user data for self with url .+, http response from API was 502}
+      end
+
+      it "should handle server timeouts" do
+        stub_timeout_self_data_request
+        EM.run_block { @adaptor.fetch_user_data_for_self }
+
+        logger_output.should =~ %r{ERROR.+Couldn't connect to .+ to fetch user data for self}
+      end
+
+      describe "when the cache is fresh" do
+        before :each do
+          @user_data = valid_user_cache_data['me']
+        end
+
+        it "should not update the user cache data" do
+          stub_self_data_request(304)
+          @adaptor.cache.expects(:get).with("user-data-me").returns(@user_data)
+          @adaptor.cache.expects(:set).never
+
+          EM.run_block { @adaptor.fetch_user_data_for_self }
+        end
+
+        it "should serve cached data" do
+          @adaptor.cache.expects(:get).with("user-data-me").returns(@user_data)
+          stub_self_data_request(304)
+          yielded_data = nil
+
+          EM.run_block {
+            @adaptor.fetch_user_data_for_self { |data| yielded_data = data }
+          }
+
+          logger_output.should =~ %r{DEBUG.+HTTP response was 304, serving user data for self from cache}
+          yielded_data.should eql(@user_data)
+        end
+      end
+
+      it "should update the user data cache when user data is stale" do
+        user_data = valid_user_cache_data['me']
+        user_data_with_etag = user_data.merge({"etag" => etag_for_data(user_data)})
+        stub_self_data_request
+        @adaptor.cache.expects(:get).with("user-data-me").returns(user_data)
+        @adaptor.cache.expects(:set).with("user-data-me", user_data_with_etag)
+
+        EM.run_block { @adaptor.fetch_user_data_for_self }
+      end
+    end
+  end
+end