nervion 0.0.1

data/spec/nervion/facade_spec.rb

@@ -0,0 +1,90 @@
+require 'nervion/facade'
+
+describe "Facade that exposes Nervion's API" do
+  let(:callback_table)   { mock(:callback_table).as_null_object }
+  let(:status_callback)  { lambda { :status_callback } }
+  let(:http_callback)    { lambda { :http_error_callback } }
+  let(:network_callback) { lambda { :network_error_callback } }
+
+  before { Nervion.stub(:callback_table).and_return(callback_table) }
+
+  it 'provides a call to set up the http error callback' do
+    callback_table.should_receive(:[]=).with(:http_error, http_callback)
+    Nervion.on_http_error(&http_callback)
+  end
+
+  it 'provides a call to set up the network error callback' do
+    callback_table.should_receive(:[]=).with(:network_error, network_callback)
+    Nervion.on_network_error(&network_callback)
+  end
+
+  context 'chaining callback setup calls' do
+    before do
+      callback_table.should_receive(:[]=).with(:http_error, http_callback)
+      callback_table.should_receive(:[]=).with(:network_error, network_callback)
+    end
+
+    it 'allows to chain callback setups' do
+      Nervion.on_http_error(&http_callback).on_network_error(&network_callback)
+    end
+
+    it 'callback setups can be chained in any order' do
+      Nervion.on_network_error(&network_callback).on_http_error(&http_callback)
+    end
+  end
+
+  context 'streaming' do
+    let(:client)  { stub(:client).as_null_object }
+    let(:config)  { Nervion::Configuration }
+    let(:params)  { Hash[stall_warnings: true] }
+    let(:request) { stub :request }
+
+    before do
+      Nervion::Client.stub(:new).
+        with(Nervion::STREAM_API_HOST, Nervion::STREAM_API_PORT).
+        and_return(client)
+    end
+
+    context 'sample endpoint' do
+      it 'sets up the status callback' do
+        callback_table.should_receive(:[]=).with(:status, status_callback)
+        Nervion.sample(&status_callback)
+      end
+
+      it 'starts the streaming to the sample endpoint' do
+        Nervion.stub(:get).with(Nervion::SAMPLE_ENDPOINT, params, config).
+          and_return(request)
+        client.should_receive(:stream).with(request, callback_table)
+        Nervion.sample(params, &status_callback)
+      end
+    end
+
+    context 'filter endpoint' do
+      it 'sets up the status callback' do
+        callback_table.should_receive(:[]=).with(:status, status_callback)
+        Nervion.filter(params, &status_callback)
+      end
+
+      it 'starts the streaming to the filter endpoint' do
+        Nervion.stub(:post).with(Nervion::FILTER_ENDPOINT, params, config).
+          and_return(request)
+        client.should_receive(:stream).with(request, callback_table)
+        Nervion.filter(params, &status_callback)
+      end
+    end
+
+    context 'stoping' do
+      it 'can stop the streaming' do
+        client.should_receive(:stop)
+        Nervion.sample(->{})
+        Nervion.stop
+      end
+
+      it 'raises an error if it is not streaming' do
+        Nervion.instance_variable_set(:@client, nil)
+        expect { Nervion.stop }.to raise_error
+      end
+    end
+  end
+
+end

data/spec/nervion/http_parser_spec.rb

@@ -0,0 +1,26 @@
+require 'nervion/http_parser'
+require 'fixtures/responses'
+
+describe Nervion::HttpParser do
+  subject           { described_class.new(json_parser) }
+  let(:json_parser) { stub(:json_parser).as_null_object }
+
+  it 'takes a JSON parser' do
+    subject.json_parser.should be json_parser
+  end
+
+  it 'can be reset' do
+    subject << RESPONSE_200
+    subject.reset!
+    expect { subject << RESPONSE_200 }.not_to raise_error Http::Parser::Error
+  end
+
+  it 'parses response body if the response status is 200' do
+    json_parser.should_receive(:<<).with(BODY_200)
+    subject << RESPONSE_200
+  end
+
+  it 'raises an error if the response status is above 200' do
+    expect { subject << RESPONSE_401 }.to raise_error Nervion::HttpError
+  end
+end

data/spec/nervion/oauth_header_spec.rb

@@ -0,0 +1,115 @@
+require 'nervion/oauth_header'
+
+describe Nervion::OAuthHeader do
+  subject { described_class.new http_method, base_url, params, oauth_params }
+
+  let(:http_method)         { 'post' }
+  let(:base_url)            { 'https://api.twitter.com/1/statuses/update.json' }
+  let(:params)              { Hash[include_entities: true, status: '@patheleven'] }
+  let(:consumer_key)        { 'xvz1evFS4wEEPTGEFPHBog' }
+  let(:consumer_secret)     { 'kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw' }
+  let(:access_token)        { 'GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb' }
+  let(:access_token_secret) { 'LswwdoUaIvS8ltyTth4J50vUPVVHtR2YPi5kE' }
+  let(:oauth_params) do
+    {
+      consumer_key: consumer_key,
+      consumer_secret: consumer_secret,
+      access_token: access_token,
+      access_token_secret: access_token_secret
+    }
+  end
+
+  it 'takes the consumer key from oauth params' do
+    subject.consumer_key.should be consumer_key
+  end
+
+  it 'takes the consumer secret from oauth params' do
+    subject.consumer_secret.should be consumer_secret
+  end
+
+  it 'takes the access token from oauth params' do
+    subject.token.should be access_token
+  end
+
+  it 'takes the access token secret from oauth params' do
+    subject.token_secret.should be access_token_secret
+  end
+
+  it 'nonce is md5 of a string formed by consumer key, token and timestamp' do
+    nonce, timestamp = stub, 123456878
+    subject.stub(:timestamp).and_return timestamp
+    string = "#{consumer_key}#{access_token}#{timestamp}"
+    Digest::MD5.stub(:hexdigest).with(string).and_return nonce
+    subject.nonce.should be nonce
+  end
+
+  it 'timestamp is seconds since epoch as string' do
+    seconds_since_epoch = stub(to_s: 'timestamp')
+    now = stub(to_i: seconds_since_epoch)
+    Time.stub(:now).and_return now
+    subject.timestamp.should eq 'timestamp'
+  end
+
+  it 'signature method is HMAC-SHA1' do
+    subject.signature_method.should eq 'HMAC-SHA1'
+  end
+
+  it 'version is 1.0' do
+    subject.version.should eq '1.0'
+  end
+
+  it 'provides a hash with the info required to create a signature' do
+    nonce, timestamp = stub(:nonce), stub(:timestamp)
+    subject.stub(:nonce).and_return nonce
+    subject.stub(:timestamp).and_return timestamp
+    oauth_info = {
+      oauth_consumer_key: consumer_key,
+      oauth_nonce: nonce,
+      oauth_signature_method: 'HMAC-SHA1',
+      oauth_timestamp: timestamp,
+      oauth_token: access_token,
+      oauth_version: '1.0'
+    }
+    subject.oauth_info.should eq oauth_info
+  end
+
+  it 'provides a hash with the consumer secret and token secret' do
+    expected_secret_hash = {
+      consumer_secret: consumer_secret,
+      access_token_secret: access_token_secret
+    }
+    subject.secrets.should eq expected_secret_hash
+  end
+
+  it 'creates the signature' do
+    signature, oauth_info = stub(:signature), stub(:oauth_info)
+    subject.stub(:oauth_info).and_return(oauth_info)
+    secrets = {
+      consumer_secret: consumer_secret,
+      access_token_secret: access_token_secret
+    }
+    Nervion::OAuthSignature.stub(:for).
+      with(http_method, base_url, params, oauth_info, secrets).
+      and_return signature
+    subject.signature.should be signature
+  end
+
+  it 'generates the authorization header value' do
+    subject.stub(:nonce).and_return 'nonce'
+    subject.stub(:timestamp).and_return 'timestamp'
+    subject.stub(:signature).and_return 'signature'
+
+    expected_header = %Q{OAuth oauth_consumer_key="#{consumer_key}", oauth_nonce="nonce", oauth_signature="signature", oauth_signature_method="HMAC-SHA1", oauth_timestamp="timestamp", oauth_token="#{access_token}", oauth_version="1.0"}
+
+    subject.to_s.should eq expected_header
+  end
+
+  it 'generates the header value for a paticular request' do
+    oauth_headers = stub :oauth_headers, to_s: 'OAuth oauth_params="value"'
+    Nervion::OAuthHeader.stub(:new).
+      with(http_method, base_url, params, oauth_params).and_return oauth_headers
+    request = stub :request, http_method: http_method, uri: base_url,
+                             params: params, oauth_params: oauth_params
+    described_class.for(request).should eq 'OAuth oauth_params="value"'
+  end
+end

data/spec/nervion/oauth_signature_spec.rb

@@ -0,0 +1,66 @@
+require 'nervion/oauth_signature'
+
+describe Nervion::OAuthSignature do
+  subject { described_class.new http_method, base_url, params, oauth_params, secrets }
+
+  let(:http_method) { 'post' }
+  let(:base_url)    { 'https://api.twitter.com/1/statuses/update.json' }
+  let(:params) do
+    {
+      include_entities: true,
+      status: 'Hello Ladies + Gentlemen, a signed OAuth request!'
+    }
+  end
+  let(:oauth_params) do
+    {
+      oauth_consumer_key:  'xvz1evFS4wEEPTGEFPHBog',
+      oauth_nonce: 'kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg',
+      oauth_signature_method: 'HMAC-SHA1',
+      oauth_timestamp: '1318622958',
+      oauth_token: '370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb',
+      oauth_version: '1.0',
+    }
+  end
+  let(:secrets) do
+    {
+      consumer_secret: 'kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw',
+      access_token_secret: 'LswwdoUaIvS8ltyTth4J50vUPVVHtR2YPi5kE'
+    }
+  end
+
+  it 'percent encodes key and value and joins the result with a "="' do
+    subject.stub(:encode).with('include_entities').and_return 'include_entities'
+    subject.stub(:encode).with('true').and_return 'true'
+    subject.encode_pair(:include_entities, true).should eq 'include_entities=true'
+  end
+
+  it 'provides the parameter string' do
+    expected_parameter_string = %q{include_entities=true&oauth_consumer_key=xvz1evFS4wEEPTGEFPHBog&oauth_nonce=kYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg&oauth_signature_method=HMAC-SHA1&oauth_timestamp=1318622958&oauth_token=370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb&oauth_version=1.0&status=Hello%20Ladies%20%2B%20Gentlemen%2C%20a%20signed%20OAuth%20request%21}
+
+    subject.parameter_string.should eq expected_parameter_string
+  end
+
+  it 'provides the signature base string' do
+    expected_signature_base_string = %q{POST&https%3A%2F%2Fapi.twitter.com%2F1%2Fstatuses%2Fupdate.json&include_entities%3Dtrue%26oauth_consumer_key%3Dxvz1evFS4wEEPTGEFPHBog%26oauth_nonce%3DkYjzVBB8Y0ZFabxSWbWovY3uYSQ2pTgmZeNu2VS4cg%26oauth_signature_method%3DHMAC-SHA1%26oauth_timestamp%3D1318622958%26oauth_token%3D370773112-GmHxMAgYyLbNEtIKZeRNFsMKPR9EyMZeS9weJAEb%26oauth_version%3D1.0%26status%3DHello%2520Ladies%2520%252B%2520Gentlemen%252C%2520a%2520signed%2520OAuth%2520request%2521}
+
+    subject.base_string.should eq expected_signature_base_string
+  end
+
+  it 'provides a signing key' do
+    expected_signing_key = 'kAcSOqF21Fu85e7zjz7ZN2U4ZRhfV3WpwPAoE3Z7kBw&LswwdoUaIvS8ltyTth4J50vUPVVHtR2YPi5kE'
+
+    subject.signing_key.should eq expected_signing_key
+  end
+
+  it 'calculates the signature' do
+    expected_signature = 'Fz/2gWGHnXm6+QRzVUtANvhr1wI='
+
+    subject.to_s.should eq expected_signature
+  end
+
+  it 'builds the signature given all the info' do
+    expected_signature = 'Fz/2gWGHnXm6+QRzVUtANvhr1wI='
+    signature = described_class.for http_method, base_url, params, oauth_params, secrets
+    signature.should eq expected_signature
+  end
+end

data/spec/nervion/percent_encoder_spec.rb

@@ -0,0 +1,20 @@
+#encoding: utf-8
+
+require 'nervion/percent_encoder'
+
+describe Nervion::PercentEncoder do
+  it 'encodes string values' do
+    subject.encode('Ladies + Gentlemen').should eq 'Ladies%20%2B%20Gentlemen'
+    subject.encode('An encoded string!').should eq 'An%20encoded%20string%21'
+    subject.encode('Dogs, Cats & Mice').should eq 'Dogs%2C%20Cats%20%26%20Mice'
+  end
+
+  it 'encodes non string values' do
+    subject.encode(123456789).should eq '123456789'
+    subject.encode(:get_post).should eq 'get_post'
+  end
+
+  it 'encodes UTF-8 values' do
+    subject.encode('☃').should eq '%E2%98%83'
+  end
+end

data/spec/nervion/reconnection_scheduler_spec.rb

@@ -0,0 +1,84 @@
+require 'nervion/reconnection_scheduler'
+
+describe Nervion::ReconnectionScheduler do
+  let(:stream) { stub(:connection).as_null_object }
+
+  before(:all) do
+    module EventMachine
+      class << self
+        alias old_add_timer add_timer
+        def add_timer(timeout); yield; end
+      end
+    end
+  end
+
+  after(:all) do
+    module EventMachine
+      class << self
+        alias add_timer old_add_timer
+      end
+    end
+  end
+
+  context 'on HTTP errors' do
+    it 'tells the stream to reconnect' do
+      stream.should_receive(:retry)
+      subject.reconnect_after_http_error_in stream
+    end
+
+    it 'waits 10 seconds before reconnecting' do
+      EM.should_receive(:add_timer).with  Nervion::HttpWaitCalculator::MIN_WAIT
+      subject.reconnect_after_http_error_in stream
+    end
+
+    it 'increases the reconnect wait exponentially up to 240 seconds' do
+      [10, 20, 40, 80, 160, 240, 240, 240, 240].each do |delay|
+        EM.should_receive(:add_timer).with delay
+        subject.reconnect_after_http_error_in stream
+      end
+    end
+
+    it 'raises an error after too many unsuccessful reconnects' do
+      limit = described_class::HTTP_ERROR_LIMIT + 1
+      expect do
+        limit.times { subject.reconnect_after_http_error_in stream }
+      end.to raise_error Nervion::TooManyConnectionErrors
+    end
+  end
+
+  context 'on network errors' do
+    it 'tells the stream to reconnect' do
+      stream.should_receive(:retry)
+      subject.reconnect_after_network_error_in stream
+    end
+
+    it 'waits 250ms before reconnecting' do
+      EM.should_receive(:add_timer).with Nervion::NetworkWaitCalculator::MIN_WAIT
+      subject.reconnect_after_network_error_in stream
+    end
+
+    it 'increases the wait after network errors linearly up to 16 seconds' do
+      (0.25..16).step(0.25) do |wait|
+        EM.should_receive(:add_timer).with wait
+        subject.reconnect_after_network_error_in stream
+      end
+    end
+
+    it 'caps the wait after network errors at 16 seconds' do
+      errors_to_cap = (16/0.25).to_i - 1
+      errors_to_limit = described_class::NETWORK_ERROR_LIMIT - errors_to_cap - 1
+      errors_to_cap.times { subject.reconnect_after_network_error_in stream }
+      errors_to_limit.times do
+        EM.should_receive(:add_timer).with(16)
+        subject.reconnect_after_network_error_in stream
+      end
+    end
+
+    it 'raises an error after too many unsuccessful reconnects' do
+      limit = described_class::NETWORK_ERROR_LIMIT + 1
+      expect do
+        limit.times { subject.reconnect_after_network_error_in stream }
+      end.to raise_error Nervion::TooManyConnectionErrors
+    end
+  end
+end

data/spec/nervion/request_spec.rb

@@ -0,0 +1,90 @@
+require 'nervion/request'
+
+EXPECTED_GET_REQUEST = <<GET
+GET /endpoint?p1=param%20value&p2=%24%26 HTTP/1.1\r
+Host: twitter.com\r
+Authorization: OAuth xxx\r\n\r
+GET
+
+EXPECTED_POST_REQUEST = <<POST
+POST /endpoint HTTP/1.1\r
+Host: twitter.com\r
+Authorization: OAuth xxx\r
+Content-Type: application/x-www-form-urlencoded\r
+Content-Length: 26\r
+\r
+p1=param%20value&p2=%24%26\r
+POST
+
+describe Nervion::Request do
+  let(:uri)          { 'https://twitter.com:443/endpoint' }
+  let(:params)       { Hash[p1: 'param value', p2: '$&'] }
+  let(:oauth_params) { Hash[param: 'value'] }
+
+  shared_examples_for 'a request' do
+    it 'is created with an uri' do
+      subject.uri.should eq 'https://twitter.com/endpoint'
+    end
+
+    it 'is created with http params' do
+      subject.params.should be params
+    end
+
+    it 'is created with oauth params' do
+      subject.oauth_params.should eq Hash[param: 'value']
+    end
+
+    it 'knows the host it points to' do
+      subject.host.should eq 'twitter.com'
+    end
+
+    it 'knows the port it will connect to' do
+      subject.port.should eq 443
+    end
+  end
+
+  context 'GET' do
+    subject { Nervion.get(uri, params, oauth_params) }
+
+    it 'has GET as http method' do
+      subject.http_method.should eq 'GET'
+    end
+
+    it 'knows the path it points to with no params' do
+      get_with_no_params = Nervion.get(uri, {}, oauth_params)
+      get_with_no_params.path.should eq '/endpoint'
+    end
+
+    it 'knows the path it points to with params' do
+      subject.path.should eq '/endpoint?p1=param%20value&p2=%24%26'
+    end
+
+
+    it 'has an string representation' do
+      Nervion::OAuthHeader.stub(:for).with(subject).and_return 'OAuth xxx'
+      subject.to_s.should eq EXPECTED_GET_REQUEST
+    end
+
+    it_behaves_like 'a request'
+  end
+
+  context 'POST' do
+    subject { Nervion.post(uri, params, oauth_params) }
+
+    it 'has POST as http method' do
+      subject.http_method.should eq 'POST'
+    end
+
+    it 'knows the path it points to' do
+      subject.path.should eq '/endpoint'
+    end
+
+    it 'has an string representation' do
+      post = Nervion.post(uri, params, oauth_params)
+      Nervion::OAuthHeader.stub(:for).with(post).and_return 'OAuth xxx'
+      post.to_s.should eq EXPECTED_POST_REQUEST
+    end
+
+    it_behaves_like 'a request'
+  end
+end