em-campfire 0.0.1 → 1.0.0

data/lib/em-campfire/users.rb

@@ -1,43 +1,25 @@
 module EventMachine
   class Campfire
     module Users
-      
-#       attr_accessor :user_cache
-      
-      private
-      
-      # Return the user_id if we haven't got the real name and
-      # kick off a user data fetch
-      def username_for(user_id)
-#         if cached_user?(user_id)
-#           user_cache[user_id]["name"]
-#         else
-          fetch_data_for(user_id)
-#           user_id.to_s
-#         end
-      end
-
-#       def is_me?(user_id)
-#         if user_cache['me']
-#           user_cache['me']['id'] == user_id
-#         else
-#           fetch_data_for('me')
-#           false
-#         end
-#       end
-# 
-#       def cached_user? user_id
-#         user_cache[user_id] != nil
-#       end
-
-      def fetch_data_for(user_id)
-        return unless user_id
+      def fetch_user_data_for_user_id(user_id, &block)
         url = "https://#{subdomain}.campfirenow.com/users/#{user_id}.json"
-        http = EventMachine::HttpRequest.new(url).get(:head => {'authorization' => [api_key, 'X'], "Content-Type" => "application/json"})
+
+        etag_header = {}
+        if cached_user_data = cache.get(user_cache_key(user_id))
+          etag_header = {"ETag" => cached_user_data["etag"]}
+        end
+
+        http = EventMachine::HttpRequest.new(url).get(:head => {'authorization' => [api_key, 'X'], "Content-Type" => "application/json"}.merge(etag_header))
+
         http.callback do
           if http.response_header.status == 200
-            logger.debug "Got the data for #{user_id}"
-            update_user_cache_with(user_id, Yajl::Parser.parse(http.response)['user'])
+            logger.debug "Got the user data for #{user_id}"
+            user_data = Yajl::Parser.parse(http.response)['user']
+            cache.set(user_cache_key(user_id), user_data.merge({'etag' => http.response_header.etag}))
+            yield user_data if block_given?
+          elsif http.response_header.status == 304
+            logger.debug "HTTP response was 304, serving user data for user 456 \(#{cached_user_data['name']}\) from cache"
+            yield cached_user_data if block_given?
           else
             logger.error "Couldn't fetch user data for user #{user_id} with url #{url}, http response from API was #{http.response_header.status}"
           end
@@ -46,11 +28,50 @@ module EventMachine
           logger.error "Couldn't connect to #{url} to fetch user data for user #{user_id}"
         end
       end
-    
-#       def update_user_cache_with(user_id, data)
-#         logger.debug "Updated user cache for #{data['name']}"
-#         user_cache[user_id] = data
-#       end
+
+      def fetch_user_data_for_self
+        url = "https://#{subdomain}.campfirenow.com/users/me.json"
+
+        etag_header = {}
+        if cached_user_data = cache.get(user_cache_key('me'))
+          etag_header = {"ETag" => cached_user_data["etag"]}
+        end
+
+        http = EventMachine::HttpRequest.new(url).get(:head => {'authorization' => [api_key, 'X'], "Content-Type" => "application/json"}) #.merge(etag_header)
+        http.callback do
+          if http.response_header.status == 200
+            logger.debug "Got the user data for self"
+            user_data = Yajl::Parser.parse(http.response)['user']
+            cache.set(user_cache_key('me'), user_data.merge({'etag' => http.response_header.etag}))
+            yield user_data if block_given?
+          elsif http.response_header.status == 304
+            logger.debug "HTTP response was 304, serving user data for self from cache"
+            yield cached_user_data if block_given?
+          else
+            logger.error "Couldn't fetch user data for self with url #{url}, http response from API was #{http.response_header.status}"
+          end
+        end
+
+        http.errback do
+          logger.error "Couldn't connect to #{url} to fetch user data for self"
+        end
+      end
+
+      def is_me?(user_id)
+        if cache_data = cache.get(user_cache_key('me'))
+          return cache_data['id'] == user_id
+        else
+          logger.debug "No user data cache exists for me, fetching it now"
+          fetch_user_data_for_self
+          return false
+        end
+      end
+
+      private
+
+      def user_cache_key(user_id)
+        "user-data-#{user_id}"
+      end
     end
   end
 end

data/lib/em-campfire/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   class Campfire
-    VERSION = "0.0.1"
+    VERSION = "1.0.0"
   end
 end

data/lib/em-campfire.rb

@@ -8,6 +8,7 @@ require "em-campfire/connection"
 require "em-campfire/rooms"
 require "em-campfire/users"
 require "em-campfire/messages"
+require "em-campfire/cache"
 
 module EventMachine
   class Campfire
@@ -21,26 +22,28 @@ module EventMachine
     def initialize(options = {})
       raise ArgumentError, "You must pass an API key" unless options[:api_key]
       raise ArgumentError, "You must pass a subdomain" unless options[:subdomain]
-      
+
       options.each do |k,v|
         s = "#{k}="
         if respond_to?(s)
           send(s, v)
         else
-          logger.warn "em-campfire initialized with #{k.inspect} => #{v.inspect} but NO UNDERSTAND!"
+          raise ArgumentError, "#{k.inspect} is not a valid option"
         end
       end
-      
-      # @rooms = {}
-#       @user_cache = {}
-      @room_cache = {}
-      
-      populate_room_list
-        
-#       # populate bot data separately, in case we are ignoring ourselves
-#       fetch_data_for('me')
+
+      fetch_user_data_for_self
+    end
+
+    def cache=(a_cache)
+      raise(ArgumentError, "You must pass a conforming cache object") unless a_cache.respond_to(:set) && a_cache.respond_to(:get)
+      @cache = a_cache
     end
-        
+
+    def cache
+      @cache ||= EventMachine::Campfire::Cache.new
+    end
+
     def logger
       unless @logger
         @logger = Logger.new(STDOUT)

data/spec/lib/cache_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe EventMachine::Campfire::Cache do
+  before :each do
+    @cache = EventMachine::Campfire::Cache.new
+  end
+
+  it "should cache data" do
+    @cache.set("foo", "bar")
+    @cache.get("foo").should eql("bar")
+  end
+
+  it "should stringify keys" do
+    @cache.set(123, "bar")
+    @cache.get("123").should eql("bar")
+    @cache.get(123).should eql("bar")
+  end
+
+  it "should yield cache data" do
+    @cache.set(123, "bar")
+    @cache.get(123) do |value|
+      value
+    end.should eql("bar")
+  end
+end

data/spec/lib/connection_spec.rb

@@ -1,12 +1,55 @@
-require "spec_helper"
+require "users_helper"
+
+class ConnectionTester < ModuleHarness
+  include EventMachine::Campfire::Connection
+  include EventMachine::Campfire::Users
+
+  def cache; @cache ||= EventMachine::Campfire::Cache.new; end
+
+  def receive_message(message)
+    process_message(message)
+  end
+end
 
 describe EventMachine::Campfire::Connection do
-    
-  context "#on_message" do
-    before :each do
-      EM.run_block { @adaptor = a EM::Campfire }
-    end
-      
-    it "run a block when it receives a message"
+  before :each do
+    mock_logger(ConnectionTester)
+    @conn = ConnectionTester.new
+  end
+
+  it "should receive messages" do
+    @conn.receive_message "foo"
+    logger_output.should =~ /DEBUG.*Received message "foo"/
+    logger_output.should =~ /DEBUG.*on_message callback does not exist/
+  end
+
+  it "should process on_message an block if present" do
+    ping = mock
+    ping.expects(:ping).with("foo")
+    @conn.on_message {|message| ping.ping(message) }
+    @conn.receive_message "foo"
+    logger_output.should =~ /DEBUG.*on_message callback exists, calling it with "foo"/
+  end
+
+  it "should be able to ignore itself" do
+    @conn.ignore_self = true
+    @conn.cache.stubs(:get).with('user-data-me').returns({'id' => 789})
+
+    ping = mock
+    ping.expects(:ping).never
+
+    @conn.on_message { ping.ping }
+    EM.run_block { @conn.receive_message({:user_id => 789}) }
+    logger_output.should =~ /Ignoring message with user_id 789 as that is me and ignore_self is true/
+  end
+
+  it "should not ignore non-self messages" do
+    stub_self_data_request
+    @conn.ignore_self = true
+
+    ping = mock
+    ping.expects(:ping).once
+    @conn.on_message { ping.ping }
+    EM.run_block { @conn.receive_message({:user_id => 2}) }
   end
 end

data/spec/lib/em-campfire_spec.rb

@@ -3,7 +3,8 @@ require "spec_helper"
 describe EventMachine::Campfire do
   
   before :each do
-    stub_rooms_data_request
+    # stub_room_list_data_request
+    @self_data_request_stub = stub_self_data_request
   end
     
   describe "#initialize" do
@@ -11,16 +12,19 @@ describe EventMachine::Campfire do
       EM.run_block { a(EM::Campfire).should be_a(EM::Campfire) }
     end
     
-    it "should warn if given an option it doesn't know" do
-      mock_logger
-      EM.run_block { a(EM::Campfire, :fred => "estaire").should be_a(EM::Campfire) }
-      logger_output.should =~ /WARN.*em-campfire initialized with :fred => "estaire" but NO UNDERSTAND!/
+    it "should raise when given an option it doesn't understand" do
+      lambda { EM::Campfire.new(valid_params.merge({:fred => "estaire"}))}.should raise_error(ArgumentError, ":fred is not a valid option")
     end
     
     it "should require essential parameters" do
       lambda { EM::Campfire.new }.should raise_error(ArgumentError, "You must pass an API key")
       lambda { EM::Campfire.new(:api_key => "foo") }.should raise_error(ArgumentError, "You must pass a subdomain")
     end
+
+    it "should fetch data about me" do
+      EM.run_block { a(EM::Campfire).should be_a(EM::Campfire) }
+      @self_data_request_stub.should have_been_requested
+    end
   end
   
   describe "#verbose" do
@@ -55,199 +59,29 @@ describe EventMachine::Campfire do
       
       it { @adaptor.logger.should be == @custom_logger }
     end
+  end
+
+  describe "#cache" do
+    before :each do
+      EM.run_block { @adaptor = a EM::Campfire }
+      @valid_cache_stub = stub(:get => "foo", :set => nil, :respond_to => true)
+    end
+
+    it "should accept a valid cache object" do
+      @adaptor.cache = @valid_cache_stub
+      @adaptor.cache.set
+      @adaptor.cache.get.should eql("foo")
+    end
+
+    it "should reject a cache object that doesn't have a conforming interface" do
+      lambda { @adaptor.cache = stub(:respond_to) }.should raise_error(ArgumentError, "You must pass a conforming cache object")
+    end
+
+    it "should provide a default cache" do
+      @adaptor.cache.set("foo", "bar")
+      @adaptor.cache.get("foo").should eql("bar")
+    end
 
-    
-    
-    # 
-    # it "should handle HTTP errors fetching individual room data" do
-    #   mock_logger
-    #   bot = a Scamp
-    # 
-    #   EM.run_block {
-    #     stub_request(:post, @message_post_url).
-    #       with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type' => 'application/json'}).
-    #       to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-    #     lambda {bot.send(:send_message, 123, "Hi", "Textmessage")}.should_not raise_error
-    #   }
-    #   logger_output.should =~ /ERROR.*Couldn't post message "Hi" to room 123 using url #{@message_post_url}, http response from the API was 502/
-    # end
-    #   
-    # it "should handle network errors fetching individual room data" do
-    #   mock_logger
-    #   bot = a Scamp
-    #     
-    #   EM.run_block {
-    #     stub_request(:post, @message_post_url).
-    #       with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type' => 'application/json'}).to_timeout
-    #     lambda {bot.send(:send_message, 123, "Hi", "Textmessage")}.should_not raise_error
-    #   }
-    #   logger_output.should =~ /ERROR.*Couldn't connect to #{@message_post_url} to post message "Hi" to room 123/
-    # end
-    # 
-    
-    
-    
-    # context "user operations" do
-       # it "should fetch user data" do
-       #   adaptor = a EM::Campfire
-       #   
-       #   EM.run_block {
-       #     stub_request(:get, "https://#{valid_params[:subdomain]}.campfirenow.com/users/123.json").
-       #       with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-       #       to_return(:status => 200, :body => Yajl::Encoder.encode(:user => valid_user_cache_data[123]), :headers => {})
-       #     adaptor.send(:username_for, 123)
-       #     stub.should have_been_requested
-       #   }
-       # end
-       
-    #    it "should handle HTTP errors fetching user data" do
-    #      mock_logger
-    #      bot = a EM::Campfire
-    #   
-    #      url = "https://#{valid_params[:subdomain]}.campfirenow.com/users/123.json"
-    #      EM.run_block {
-    #        stub_request(:get, url).
-    #          with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-    #          to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-    #        lambda {bot.username_for(123)}.should_not raise_error
-    #      }
-    #      logger_output.should =~ /ERROR.*Couldn't fetch user data for user 123 with url #{url}, http response from API was 502/
-    #    end
-    #    
-    #    it "should handle network errors fetching user data" do
-    #      mock_logger
-    #      bot = a EM::Campfire
-    #      
-    #      url = "https://#{valid_params[:subdomain]}.campfirenow.com/users/123.json"
-    #      EM.run_block {
-    #        stub_request(:get, url).
-    #          with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).to_timeout
-    #        lambda {bot.username_for(123)}.should_not raise_error
-    #      }
-    #      logger_output.should =~ /ERROR.*Couldn't connect to #{url} to fetch user data for user 123/
-    #    end
-     end
-     
-    context "room operations" do
-      before do
-        @room_list_url = "https://#{valid_params[:subdomain]}.campfirenow.com/rooms.json"
-        @me_list_url = "https://#{valid_params[:subdomain]}.campfirenow.com/users/me.json"
-        @room_url = "https://#{valid_params[:subdomain]}.campfirenow.com/room/123.json"
-        @stream_url = "https://streaming.campfirenow.com/room/123/live.json"
-      end
-      
-      # it "should fetch a room list" do
-      #   mock_logger
-      #   bot = a EM::Campfire
-      #   
-      #   EM.run_block {
-      #     stub_request(:get, @room_list_url).
-      #       with(:headers => {'Authorization'=>[valid_params[:api_key], 'X']}).
-      #       to_return(:status => 200, :body => Yajl::Encoder.encode(:rooms => valid_room_cache_data.values), :headers => {})
-      #     bot.send(:populate_room_list)
-      #     stub.should have_been_requested
-      #   }
-      #   logger_output.should =~ /DEBUG.*Fetched room list/
-      # end
-  
-  #     it "should invoke the post connection callback" do
-  #       mock_logger
-  #       bot = a EM::Campfire
-  # 
-  #       invoked_cb = false
-  # 
-  #       EM.run_block {
-  #         stub_request(:get, @room_list_url).
-  #         with(:headers => {
-  #                'Authorization'=>[valid_params[:api_key], 'X'],
-  #                'Content-Type' => 'application/json'
-  #              }).
-  #         to_return(:status => 200, :body => Yajl::Encoder.encode(:rooms => valid_room_cache_data.values), :headers => {})
-  # 
-  #         stub_request(:get, @room_list_url).
-  #         with(:headers => {
-  #                'Authorization'=>[valid_params[:api_key], 'X']
-  #              }).
-  #         to_return(:status => 200, :body => Yajl::Encoder.encode(:rooms => valid_room_cache_data.values), :headers => {})
-  # 
-  #         # Disable fetch_data_for, not important to this test.
-  #         EM::Campfire.any_instance.expects(:fetch_data_for).returns(nil)
-  # 
-  #         bot.send(:connect!, [valid_room_cache_data.keys.first]) do
-  #           invoked_cb = true
-  #         end
-  #       }
-  #       invoked_cb.should be_true
-  #     end
-  # 
-  #     it "should handle HTTP errors fetching the room list" do
-  #       mock_logger
-  #       bot = a EM::Campfire
-  #     
-  #       EM.run_block {
-  #         # stub_request(:get, url).
-  #         #   with(:headers => {'Authorization'=>[valid_params[:api_key], 'X'], 'Content-Type'=>'application/json'}).
-  #         #   to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-  #         stub_request(:get, @room_list_url).
-  #           with(:headers => {'Authorization'=>[valid_params[:api_key], 'X']}).
-  #           to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-  #         lambda {bot.send(:populate_room_list)}.should_not raise_error
-  #       }
-  #       logger_output.should =~ /ERROR.*Couldn't fetch room list with url #{@room_list_url}, http response from API was 502/
-  #     end
-  #     
-  #     it "should handle network errors fetching the room list" do
-  #       mock_logger
-  #       bot = a EM::Campfire
-  #       EM.run_block {
-  #         stub_request(:get, @room_list_url).
-  #           with(:headers => {'Authorization'=>[valid_params[:api_key], 'X']}).to_timeout
-  #         lambda {bot.send(:populate_room_list)}.should_not raise_error
-  #       }
-  #       logger_output.should =~ /ERROR.*Couldn't connect to url #{@room_list_url} to fetch room list/
-  #     end
-  #     
-  #     it "should fetch individual room data" do
-  #       mock_logger
-  #       bot = a EM::Campfire
-  #       
-  #       EM.run_block {
-  #         stub_request(:get, @room_url).
-  #           with(:headers => {'Authorization'=>[valid_params[:api_key], 'X']}).
-  #           to_return(:status => 200, :body => Yajl::Encoder.encode(:room => valid_room_cache_data[123]), :headers => {})
-  #         bot.room_name_for(123)
-  #       }
-  #       logger_output.should =~ /DEBUG.*Fetched room data for 123/
-  #     end
-  #     
-  #     it "should handle HTTP errors fetching individual room data" do
-  #       mock_logger
-  #       bot = a EM::Campfire
-  # 
-  #       EM.run_block {
-  #         stub_request(:get, @room_url).
-  #           with(:headers => {'Authorization'=>[valid_params[:api_key], 'X']}).
-  #           to_return(:status => 502, :body => "", :headers => {'Content-Type'=>'text/html'})
-  #         lambda {bot.room_name_for(123)}.should_not raise_error
-  #       }
-  #       logger_output.should =~ /ERROR.*Couldn't fetch room data for room 123 with url #{@room_url}, http response from API was 502/
-  #     end
-  #     
-  #     it "should handle network errors fetching individual room data" do
-  #       mock_logger
-  #       bot = a EM::Campfire
-  #       
-  #       EM.run_block {
-  #         stub_request(:get, @room_url).
-  #           with(:headers => {'Authorization'=>[valid_params[:api_key], 'X']}).to_timeout
-  #         lambda {bot.room_name_for(123)}.should_not raise_error
-  #       }
-  #       logger_output.should =~ /ERROR.*Couldn't connect to #{@room_url} to fetch room data for room 123/
-  #     end
-  #     
-  #     it "should stream a room"
-  #     it "should handle HTTP errors streaming a room"
-  #     it "should handle network errors streaming a room"
   end
 end