em-twitter 0.1.0

data/lib/em-twitter/response.rb

@@ -0,0 +1,48 @@
+module EventMachine
+  module Twitter
+    class Response
+
+      attr_reader :body
+
+      def initialize(body = '')
+        @body = body
+      end
+
+      def concat(data)
+        return unless data && data.size > 0
+
+        data.strip!
+
+        return if data.empty?
+
+        if json_start?(data) || json_end?(data)
+          @body << data
+        end
+      end
+      alias :<< :concat
+
+      def complete?
+        json_start?(@body) && json_end?(@body)
+      end
+
+      def empty?
+        @body == ''
+      end
+
+      def reset
+        @body = ''
+      end
+
+      private
+
+      def json_start?(data)
+        data[0,1] == '{'
+      end
+
+      def json_end?(data)
+        data[data.length-1,1] == '}'
+      end
+
+    end
+  end
+end

data/lib/em-twitter/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module Twitter
+    VERSION = "0.1.0" unless defined?(EventMachine::Twitter::VERSION)
+  end
+end

data/lib/em_twitter.rb

@@ -0,0 +1 @@
+require 'em-twitter'

data/smoke.rb

@@ -0,0 +1,66 @@
+require 'bundler/setup'
+require 'em-twitter'
+
+EM::run do
+
+  options = {
+    :path   => '/1/statuses/filter.json',
+    :params => {
+      :track            => 'you,Obama,eli,bachelor,Romney'
+    },
+    :ssl => {
+      :verify_peer      => true,
+      :cert_chain_file  => '/etc/ssl/certs/cacert.pem'
+    },
+    :oauth  => {
+      :consumer_key     => 'czveJ6LqlTuVHsbDBuRQ',
+      :consumer_secret  => 'wGY6NCptPerGog4lPvAKu450jtUaT3bz7wSQdzDiYaY',
+      :token            => '4618-01z5ihmeVYuc343JAYzaejVTuV0VU5CSF7gUWzsB8',
+      :token_secret     => 'HVQrPKjfQAyNPkQCCej10dIaLUaFzIIEAkwsI1hQ0'
+    }
+    # , :encoding => 'gzip'
+  }
+
+  client = EM::Twitter::Client.connect(options)
+
+  client.each do |item|
+    puts item
+  end
+
+  client.on_error do |message|
+    puts "oops: error: #{message}"
+  end
+
+  client.on_unauthorized do
+    puts "oops: unauthorized"
+  end
+
+  client.on_forbidden do
+    puts "oops: unauthorized"
+  end
+
+  client.on_not_found do
+    puts "oops: not_found"
+  end
+
+  client.on_not_acceptable do
+    puts "oops: not_acceptable"
+  end
+
+  client.on_too_long do
+    puts "oops: too_long"
+  end
+
+  client.on_range_unacceptable do
+    puts "oops: range_unacceptable"
+  end
+
+  client.on_enhance_your_calm do
+    puts "oops: enhance_your_calm"
+  end
+
+  EM.add_timer(25) do
+    EM.stop
+  end
+
+end

data/spec/em-twitter/client_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe EM::Twitter::Client do
+
+  describe '.connect' do
+    before do
+      conn = stub('EventMachine::Connection')
+      conn.stub(:start_tls).and_return(nil)
+      EM.stub(:connect).and_return(conn)
+    end
+
+    context 'without a proxy' do
+      it 'connects to the configured host/port' do
+        EventMachine.should_receive(:connect)
+          .with(test_options[:host],
+                test_options[:port],
+                EventMachine::Twitter::Connection,
+                kind_of(EM::Twitter::Client),
+                test_options[:host],
+                test_options[:port])
+        EM::Twitter::Client.connect(default_options)
+      end
+    end
+
+    context 'when using a proxy' do
+      it 'connects to the proxy server' do
+        EventMachine.should_receive(:connect)
+          .with("my-proxy",
+                8080,
+                EventMachine::Twitter::Connection,
+                kind_of(EM::Twitter::Client),
+                'my-proxy',
+                8080)
+        EM::Twitter::Client.connect(default_options.merge(proxy_options))
+      end
+    end
+
+    it "should not trigger SSL until connection is established" do
+      connection = stub('EventMachine::Connection')
+      EM.should_receive(:connect).and_return(connection)
+      EM.should_not_receive(:start_tls)
+      client = EM::Twitter::Client.connect(:ssl => { :key => "/path/to/key.pem", :cert => "/path/to/cert.pem" })
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'delegate to the connection' do
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.respond_to?(:immediate_reconnect).should be_true
+      end
+    end
+  end
+
+end

data/spec/em-twitter/connection_error_handling_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'EM::Twitter::Connection error handling' do
+  error_callback_invoked('on_unauthorized', 401, 'Unauthorized')
+  error_callback_invoked('on_forbidden', 403, 'Forbidden')
+  error_callback_invoked('on_not_found', 404, 'Not Found')
+  error_callback_invoked('on_not_acceptable', 406, 'Not Acceptable')
+  error_callback_invoked('on_too_long', 413, 'Too Long')
+  error_callback_invoked('on_range_unacceptable', 416, 'Range Unacceptable')
+  error_callback_invoked('on_enhance_your_calm', 420, 'Enhance Your Calm')
+  error_callback_invoked('on_error', 500, 'Internal Server Error', 'An error occurred.')
+end

data/spec/em-twitter/connection_reconnect_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+include EM::Twitter
+
+describe 'EM::Twitter::Connection reconnections' do
+
+  describe '#reconnect' do
+    before do
+      Mockingbird.setup(test_options) do
+        on_connection(1) do
+          disconnect!
+        end
+      end
+    end
+
+    after { Mockingbird.teardown }
+
+    it 'calls the on_reconnect callback on reconnects' do
+      called = false
+
+      EM.run do
+        client = Client.connect(default_options)
+        client.on_reconnect { called = true; EM.stop }
+      end
+
+      called.should be_true
+    end
+
+    it 'does not reconnect when auto_reconnect is false' do
+      EM.run do
+        client = Client.connect(default_options.merge(:auto_reconnect => false))
+        client.should_not_receive(:reconnect)
+        client.on_close { EM.stop }
+      end
+    end
+  end
+
+  describe '#immediate_reconnect' do
+    before do
+      Mockingbird.setup(test_options) do
+        100.times do
+          send '{"foo":"bar"}'
+        end
+      end
+    end
+
+    after { Mockingbird.teardown }
+
+    it 'reconnects immediately' do
+      called = false
+
+      EM.run_block do
+        client = Client.connect(default_options)
+        client.on_reconnect { called = true; EM.stop }
+        client.immediate_reconnect
+      end
+
+      called.should be_true
+    end
+
+    it 'reconnects the current connection' do
+      EM.run_block do
+        client = Client.connect(default_options)
+        client.connection.should_receive(:reconnect).once
+        client.reconnect
+      end
+    end
+  end
+
+  describe '#on_max_reconnects' do
+    context 'application failure' do
+      before do
+        Mockingbird.setup(test_options) do
+          status 200, "Success"
+
+          on_connection('*') do
+            disconnect!
+          end
+        end
+      end
+
+      after { Mockingbird.teardown }
+
+      it "should notify after reconnect limit is reached" do
+        timeout, retries = nil, nil
+
+        EM.run do
+          client = Client.new(default_options)
+          client.on_max_reconnects do |t, r|
+            timeout, retries = t, r
+            EM.stop
+          end
+          client.connect
+
+          # do this so that EM doesn't create timers that grind
+          # this test to a halt
+          client.connection.reconnector = Reconnectors::ApplicationFailure.new(:reconnect_count => 320)
+        end
+
+        timeout.should eq(20)
+        retries.should eq(321)
+      end
+    end
+
+    context 'network failure' do
+      before do
+        Mockingbird.setup(test_options) do
+          status 200, "Success"
+
+          on_connection('*') do
+            disconnect!
+          end
+        end
+      end
+
+      after { Mockingbird.teardown }
+
+      it "should notify after reconnect limit is reached" do
+        timeout, retries = nil, nil
+
+        EM.run do
+          client = Client.new(default_options)
+          client.on_max_reconnects do |t, r|
+            timeout, retries = t, r
+            EM.stop
+          end
+          client.connect
+
+          # do this so that EM doesn't create timers that grind
+          # this test to a halt
+          client.connection.reconnector = Reconnectors::NetworkFailure.new(:reconnect_count => 320)
+        end
+
+        timeout.should eq(0.5)
+        retries.should eq(321)
+      end
+    end
+  end
+end

data/spec/em-twitter/connection_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe EM::Twitter::Connection do
+
+  describe '#post_init' do
+    it 'calls the on_inited callback' do
+      called = false
+
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options.merge(:on_inited => lambda { called = true}))
+      end
+
+      called.should be_true
+    end
+
+    it 'sets the inactivity timeout' do
+      EM.should_receive(:set_comm_inactivity_timeout)
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options.merge(:timeout => 2))
+      end
+    end
+  end
+
+  describe 'streaming' do
+    describe '#receive_data' do
+      before do
+        Mockingbird.setup(test_options) do
+          100.times do
+            send '{"foo":"ba'
+            send 'r"}'
+          end
+        end
+      end
+
+      after { Mockingbird.teardown }
+
+      it 'converts response data into complete buffers' do
+        count = 0
+
+        EM.run do
+          client = EM::Twitter::Client.connect(default_options)
+          client.each do |message|
+            count = count + 1
+            EM.stop if count == 100
+          end
+        end
+
+        count.should == 100
+      end
+    end
+
+    describe '#each' do
+      before do
+        Mockingbird.setup(test_options) do
+          100.times do
+            send '{"foo":"bar"}'
+          end
+        end
+      end
+
+      after { Mockingbird.teardown }
+
+      it 'emits each complete response chunk' do
+        count = 0
+
+        EM.run do
+          client = EM::Twitter::Client.connect(default_options)
+          client.each do |message|
+            count = count + 1
+            EM.stop if count == 100
+          end
+        end
+
+        count.should == 100
+      end
+    end
+  end
+
+  describe "#on_close" do
+    it "sets a callback that is invoked when the connection closes" do
+      called = false
+
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.on_close { called = true }
+      end
+
+      called.should be_true
+    end
+  end
+
+  describe '#stop' do
+    it 'closes the connection' do
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.connection.should_receive(:close_connection).once
+        client.stop
+      end
+    end
+
+    it 'gracefully closes' do
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.stop
+        client.should be_gracefully_closed
+      end
+    end
+  end
+
+  describe '#update' do
+    before do
+      Mockingbird.setup(test_options) do
+        100.times do
+          send '{"foo":"bar"}'
+        end
+      end
+    end
+
+    after { Mockingbird.teardown }
+
+    it 'updates the options hash' do
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.connection.update(:params => { :track => 'rangers' })
+        client.connection.options[:params].should eq({:track => 'rangers'})
+      end
+    end
+
+    it 'reconnects after updating' do
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.connection.should_receive(:immediate_reconnect).once
+        client.connection.update(:params => { :track => 'rangers' })
+      end
+    end
+
+    it 'uses the new options when reconnecting' do
+      EM.run_block do
+        client = EM::Twitter::Client.connect(default_options)
+        client.connection.should_receive(:send_data) do |request|
+          request.to_s.should include('track=rangers')
+        end
+        client.connection.update(:params => { :track => 'rangers' })
+      end
+    end
+  end
+
+end