RubyGems - zeppelin - Versions diffs - 0.5.0 → 0.6.0 - Mend

zeppelin 0.5.0 → 0.6.0

Files changed (23) hide show

data/.gitignore +2 -3
data/.travis.yml +2 -1
data/.yardopts +4 -1
data/Changelog.md +28 -0
data/Gemfile +9 -1
data/Guardfile +10 -0
data/Rakefile +7 -7
data/lib/zeppelin.rb +97 -47
data/lib/zeppelin/middleware.rb +7 -0
data/lib/zeppelin/middleware/json_parser.rb +37 -0
data/lib/zeppelin/middleware/response_raise_error.rb +22 -0
data/lib/zeppelin/version.rb +1 -1
data/spec/middleware/json_parser_spec.rb +34 -0
data/spec/middleware/response_raise_error_spec.rb +32 -0
data/spec/spec_helper.rb +7 -0
data/spec/zeppelin_spec.rb +470 -0
data/zeppelin.gemspec +4 -7
metadata +30 -62
data/.autotest +0 -15
data/lib/zeppelin/json_parser_middleware.rb +0 -35
data/test/json_parser_middleware_test.rb +0 -35
data/test/test_helper.rb +0 -13
data/test/zeppelin_test.rb +0 -453

data/lib/zeppelin/middleware/response_raise_error.rb ADDED

@@ -0,0 +1,22 @@
+class Zeppelin
+  class ResourceNotFound < Faraday::Error::ResourceNotFound
+  end
+  class ClientError < Faraday::Error::ClientError
+  end
+  module Middleware
+    # Intercept Faraday errors and re-raise our own to hide implementation details
+    #
+    # @private
+    class ResponseRaiseError < Faraday::Response::RaiseError
+      def on_complete(env)
+        super
+      rescue Faraday::Error::ResourceNotFound => msg
+        raise ResourceNotFound, msg
+      rescue Faraday::Error::ClientError => msg
+        raise ClientError, msg
+      end
+    end
+  end
+end

data/lib/zeppelin/version.rb CHANGED

@@ -1,3 +1,3 @@
 class Zeppelin
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/spec/middleware/json_parser_spec.rb ADDED

@@ -0,0 +1,34 @@
+require 'spec_helper'
+describe Zeppelin::Middleware::JsonParser do
+  let(:json_body) { "{\"foo\":\"bar\"}" }
+  let(:expected_parsed_body) { { 'foo' => 'bar' } }
+  it 'parses a standard JSON content type' do
+    process(json_body, 'application/json').body.should eq(expected_parsed_body)
+  end
+  it 'parses vendor JSON content type' do
+    process(json_body, 'application/vnd.urbanairship+json').body.should eq(expected_parsed_body)
+  end
+  it 'does not change nil body' do
+    process(nil).body.should be_nil
+  end
+  it 'does not parse non-JSON content types' do
+    process('<hello>world</hello>', 'text/xml').body.should eq('<hello>world</hello>')
+  end
+  def process(body, content_type=nil, options={})
+    env = { :body => body, :response_headers => Faraday::Utils::Headers.new }
+    env[:response_headers]['content-type'] = content_type if content_type
+    middleware = Zeppelin::Middleware::JsonParser.new(
+      lambda { |env| Faraday::Response.new(env) }
+    )
+    middleware.call(env)
+  end
+end

data/spec/middleware/response_raise_error_spec.rb ADDED

@@ -0,0 +1,32 @@
+require 'spec_helper'
+describe Zeppelin::Middleware::ResponseRaiseError do
+  subject do
+    Faraday.new do |b|
+      b.use(described_class)
+      b.adapter :test do |stub|
+        stub.get('ok')        { [200, { 'Content-Type' => 'text/html' }, '<body></body>'] }
+        stub.get('not-found') { [404, { 'X-Reason' => 'because' }, 'keep looking'] }
+        stub.get('error')     { [500, { 'X-Error' => 'bailout' }, 'fail' ] }
+      end
+    end
+  end
+  it 'does nothing when the response is successful' do
+    expect {
+      subject.get('ok')
+    }.to_not raise_error
+  end
+  it 'raises an error when the resource was not found' do
+    expect {
+      subject.get('not-found')
+    }.to raise_error(Zeppelin::ResourceNotFound)
+  end
+  it 'raises an error when a client error occurs' do
+    expect {
+      subject.get('error')
+    }.to raise_error(Zeppelin::ClientError)
+  end
+end

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'zeppelin'
+RSpec.configure do |config|
+end

data/spec/zeppelin_spec.rb ADDED

@@ -0,0 +1,470 @@
+require 'spec_helper'
+describe Zeppelin do
+  let(:device_token) { '1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF' }
+  let(:app_key) { 'app key' }
+  let(:master_secret) { 'app master secret' }
+  let(:options) { { :ssl => { :ca_path => '/dev/null' } } }
+  subject { Zeppelin.new(app_key, master_secret, options) }
+  describe '.new' do
+    its(:application_key) { should eq(app_key) }
+    its(:application_master_secret) { should eq(master_secret) }
+    its(:options) { should eq(options) }
+  end
+  describe '#connection' do
+    it { subject.connection.should be_a(Faraday::Connection) }
+    it { subject.connection.scheme.should eq('https') }
+    it { subject.connection.host.should eq('go.urbanairship.com') }
+    it { subject.connection.builder.handlers.should include(Faraday::Adapter::NetHttp) }
+    it { subject.connection.builder.handlers.should include(Faraday::Request::JSON) }
+    it { subject.connection.builder.handlers.should include(Zeppelin::Middleware::JsonParser) }
+    it { subject.connection.builder.handlers.should include(Zeppelin::Middleware::ResponseRaiseError) }
+    it { subject.connection.headers['Authorization'].should eq('Basic YXBwIGtleTphcHAgbWFzdGVyIHNlY3JldA==') }
+  end
+  describe '#register_device_token' do
+    let(:payload) { { :alias => 'CapnKernul' } }
+    it 'registers a device with the service' do
+      stub_requests do |stub|
+        stub.put("/api/device_tokens/#{device_token}") do |stub|
+          [201, {}, '']
+        end
+      end
+      subject.register_device_token(device_token).should be_true
+    end
+    it 'accepts a payload' do
+      stub_requests do |stub|
+        stub.put("/api/device_tokens/#{device_token}", MultiJson.encode(payload)) do
+          [200, {}, '']
+        end
+      end
+      subject.register_device_token(device_token, payload).should be_true
+    end
+    it 'responds with false when an error occurs' do
+      stub_requests do |stub|
+        stub.put("/api/device_tokens/#{device_token}", nil) do
+          [500, {}, '']
+        end
+      end
+      expect {
+        subject.register_device_token(device_token)
+      }.to raise_error(Zeppelin::ClientError)
+    end
+  end
+  describe '#device_token' do
+    let(:response_body) { { 'foo' => 'bar' } }
+    it 'gets information about a device' do
+      stub_requests do |stub|
+        stub.get("/api/device_tokens/#{device_token}") do
+          [200, { 'Content-Type' => 'application/json' }, MultiJson.encode(response_body)]
+        end
+      end
+      subject.device_token(device_token).should eq(response_body)
+    end
+    it 'is nil when the request fails' do
+      stub_requests do |stub|
+        stub.get("/api/device_tokens/#{device_token}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.device_token(device_token)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#delete_device_token' do
+    it 'is true when successful' do
+      stub_requests do |stub|
+        stub.delete("/api/device_tokens/#{device_token}") do
+          [204, {}, '']
+        end
+      end
+      subject.delete_device_token(device_token).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.delete("/api/device_tokens/#{device_token}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.delete_device_token(device_token)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#register_apid' do
+    let(:payload) { { :alias => 'CapnKernul' } }
+    it 'registers a device with the service' do
+      stub_requests do |stub|
+        stub.put("/api/apids/#{device_token}") do |stub|
+          [201, {}, '']
+        end
+      end
+      subject.register_apid(device_token).should be_true
+    end
+    it 'accepts a payload' do
+      stub_requests do |stub|
+        stub.put("/api/apids/#{device_token}", MultiJson.encode(payload)) do
+          [200, {}, '']
+        end
+      end
+      subject.register_apid(device_token, payload).should be_true
+    end
+    it 'responds with false when an error occurs' do
+      stub_requests do |stub|
+        stub.put("/api/apids/#{device_token}", nil) do
+          [500, {}, '']
+        end
+      end
+      expect {
+        subject.register_apid(device_token)
+      }.to raise_error(Zeppelin::ClientError)
+    end
+  end
+  describe '#apid' do
+    let(:response_body) { { 'foo' => 'bar' } }
+    it 'responds with information about a device when request is successful' do
+      stub_requests do |stub|
+        stub.get("/api/apids/#{device_token}") do
+          [200, { 'Content-Type' => 'application/json' }, MultiJson.encode(response_body)]
+        end
+      end
+      subject.apid(device_token).should eq(response_body)
+    end
+    it 'is nil when the request fails' do
+      stub_requests do |stub|
+        stub.get("/api/apids/#{device_token}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.apid(device_token)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#delete_apid' do
+    it 'responds with true when request successful' do
+      stub_requests do |stub|
+          stub.delete("/api/apids/#{device_token}") do
+          [204, {}, '']
+        end
+      end
+      subject.delete_apid(device_token).should be_true
+    end
+    it 'responds with false when request fails' do
+      stub_requests do |stub|
+        stub.delete("/api/apids/#{device_token}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.delete_apid(device_token)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#push' do
+    let(:payload) { { :device_tokens => [device_token], :aps => { :alert => 'Hello from Urban Airship!' } } }
+    it 'is true when the request is successful' do
+      stub_requests do |stub|
+        stub.post('/api/push/', MultiJson.encode(payload)) do
+          [200, {}, '']
+        end
+      end
+      subject.push(payload).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.post('/api/push/', '{}') do
+          [400, {}, '']
+        end
+      end
+      expect {
+        subject.push({})
+      }.to raise_error(Zeppelin::ClientError)
+    end
+  end
+  describe '#batch_push' do
+    let(:message1) {
+      {
+        :device_tokens => [@device_token],
+        :aps => { :alert => 'Hello from Urban Airship!' }
+      }
+    }
+    let(:message2) {
+      {
+        :device_tokens => [],
+        :aps => { :alert => 'Yet another hello from Urban Airship!' }
+      }
+    }
+    let(:payload) { [message1, message2] }
+    it 'is true when the request was successful' do
+      stub_requests do |stub|
+        stub.post('/api/push/batch/', MultiJson.encode(payload)) do
+         [200, {}, '']
+        end
+      end
+      subject.batch_push(message1, message2).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.post('/api/push/batch/', '[{},{}]') do
+          [400, {}, '']
+        end
+      end
+      expect {
+        subject.batch_push({}, {})
+      }.to raise_error(Zeppelin::ClientError)
+    end
+  end
+  describe '#broadcast' do
+    let(:payload) {  { :aps => { :alert => 'Hello from Urban Airship!' } } }
+    it 'is true when the request is successful' do
+      stub_requests do |stub|
+        stub.post('/api/push/broadcast/', MultiJson.encode(payload)) do
+          [200, {}, '']
+        end
+      end
+      subject.broadcast(payload).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.post('/api/push/broadcast/', '{}') do
+          [400, {}, '']
+        end
+      end
+      expect {
+        subject.broadcast({})
+      }.to raise_error(Zeppelin::ClientError)
+    end
+  end
+  describe '#feedback' do
+    let(:response_body) { { 'foo' => 'bar' } }
+    let(:since) { Time.at(0) }
+    it 'is the response body for a successful request' do
+      stub_requests do |stub|
+        stub.get('/api/device_tokens/feedback/?since=1970-01-01T00%3A00%3A00Z') do
+          [200, { 'Content-Type' => 'application/json' }, MultiJson.encode(response_body)]
+        end
+      end
+      subject.feedback(since)
+    end
+    it 'is nil when the request fails' do
+      stub_requests do |stub|
+        stub.get('/api/device_tokens/feedback/?since=1970-01-01T00%3A00%3A00Z') do
+          [400, {}, '']
+        end
+      end
+      expect {
+        subject.feedback(since)
+      }.to raise_error(Zeppelin::ClientError)
+    end
+  end
+  describe '#modify_device_token_on_tag' do
+    let(:tag_name) { 'jimmy.page' }
+    let(:device_token) { 'CAFEBABE' }
+    it 'requets to modify device tokens on a tag' do
+      stub_requests do |stub|
+        stub.post("/api/tags/#{tag_name}") do
+          [200, {}, 'OK']
+        end
+      end
+      subject.modify_device_tokens_on_tag(tag_name, { 'device_tokens' => { 'add' => [device_token] } }).should be
+    end
+  end
+  describe '#add_tag' do
+    let(:tag_name) { 'chunky.bacon' }
+    it 'is true when the request is successful' do
+      stub_requests do |stub|
+        stub.put("/api/tags/#{tag_name}") do
+          [201, {}, '']
+        end
+      end
+      subject.add_tag(tag_name).should be_true
+    end
+  end
+  describe '#remove_tag' do
+    let(:tag_name) { 'cats.pajamas' }
+    it 'is true when the request is successful' do
+      stub_requests do |stub|
+        stub.delete("/api/tags/#{tag_name}") do
+          [204, {}, '']
+        end
+      end
+      subject.remove_tag(tag_name).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.delete("/api/tags/#{tag_name}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.remove_tag(tag_name)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#device_tags' do
+    let(:response_body) { { 'tags' => ['tag1', 'some_tag'] } }
+    it 'is the collection of tags on a device when request is successful' do
+      stub_requests do |stub|
+        stub.get("/api/device_tokens/#{device_token}/tags/") do
+          [200, { 'Content-Type' => 'application/json' }, MultiJson.encode(response_body)]
+        end
+      end
+      subject.device_tags(device_token).should eq(response_body)
+    end
+    it 'is nil when the request fails' do
+      stub_requests do |stub|
+        stub.get("/api/device_tokens/#{device_token}/tags/") do
+          [404, {}, 'Not Found']
+        end
+      end
+      expect {
+        subject.device_tags(device_token)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#add_tag_to_device' do
+    let(:tag_name) { 'radio.head' }
+    it 'is true when the request is successful' do
+      stub_requests do |stub|
+        stub.put("/api/device_tokens/#{device_token}/tags/#{tag_name}") do
+          [201, {}, 'Created']
+        end
+      end
+      subject.add_tag_to_device(device_token, tag_name).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.put("/api/device_tokens/#{device_token}/tags/#{tag_name}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.add_tag_to_device(device_token, tag_name)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  describe '#remove_tag_from_device' do
+    let(:tag_name) { 'martin.fowler' }
+    it 'is true when the request is successful' do
+      stub_requests do |stub|
+        stub.delete("/api/device_tokens/#{device_token}/tags/#{tag_name}") do
+          [204, {}, 'No Content']
+        end
+      end
+      subject.remove_tag_from_device(device_token, tag_name).should be_true
+    end
+    it 'is false when the request fails' do
+      stub_requests do |stub|
+        stub.delete("/api/device_tokens/#{device_token}/tags/#{tag_name}") do
+          [404, {}, '']
+        end
+      end
+      expect {
+        subject.remove_tag_from_device(device_token, tag_name)
+      }.to raise_error(Zeppelin::ResourceNotFound)
+    end
+  end
+  def stub_requests(&block)
+    subject.connection.builder.handlers.delete(Faraday::Adapter::NetHttp)
+    subject.connection.adapter(:test, &block)
+  end
+end