instedd-pigeon 0.1.3 → 0.2.0

data/lib/pigeon/utils.rb

@@ -0,0 +1,70 @@
+module Pigeon
+  module Utils
+
+    def to_query(hash)
+      hash.map do |key, value|
+        "#{key.to_s}=#{CGI.escape(value.to_s)}"
+      end.join('&')
+    end
+
+    def handle_channel_error(error)
+      if error.is_a? RestClient::BadRequest
+        response = JSON.parse error.response.body
+        raise self.class.error_class.new response['summary'], Hash[response['properties'].map {|e| [e.keys[0], e.values[0]]}]
+      else
+        raise self.class.error_class.new error.message
+      end
+    end
+
+    def with_indifferent_access(hash)
+      if hash.respond_to? :with_indifferent_access
+        hash.with_indifferent_access
+      else
+        hash
+      end
+    end
+
+    def get(path)
+      resource = RestClient::Resource.new @url, @options
+      resource = resource[path].get
+      yield resource, nil
+    rescue => ex
+      yield nil, ex
+    end
+
+    def get_json(path)
+      get(path) do |response, error|
+        raise self.class.error_class.new error.message if error
+
+        elem = JSON.parse response.body
+        elem.map! { |x| with_indifferent_access x } if elem.is_a? Array
+        elem
+      end
+    end
+
+    def post(path, data)
+      resource = RestClient::Resource.new @url, @options
+      resource = resource[path].post(data)
+      yield resource, nil
+    rescue => ex
+      yield nil, ex
+    end
+
+    def put(path, data)
+      resource = RestClient::Resource.new @url, @options
+      resource = resource[path].put(data)
+      yield resource, nil
+    rescue => ex
+      yield nil, ex
+    end
+
+    def delete(path)
+      resource = RestClient::Resource.new @url, @options
+      resource = resource[path].delete
+      yield resource, nil
+    rescue => ex
+      yield nil, ex
+    end
+
+  end
+end

data/lib/pigeon/verboice.rb

@@ -1,10 +1,154 @@
-require 'verboice'
+# Provides access to the Verboice Public API.
+# Taken from verboice-api-ruby gem version 0.7.0
+# See http://bitbucket.org/instedd/verboice-api-ruby
+#
 
-class Verboice
-  def self.from_config
-    config = Pigeon.config
+require 'net/http'
+require 'json'
+require 'rest_client'
+require 'cgi'
+require 'time'
+require 'pigeon/errors'
+require 'pigeon/utils'
+
+module Pigeon
+  class Verboice
+    include Pigeon::Utils
+
+    def self.error_class
+      Pigeon::VerboiceException
+    end
+
+    def self.from_config
+      config = Pigeon.config
+
+      self.new config.verboice_host, config.verboice_account, config.verboice_password
+    end
+
+    # Creates an account-authenticated Verboice api access.
+    def initialize(url, account, password, default_channel = nil)
+      @url = url
+      @account = account
+      @password = password
+      @default_channel = default_channel
+      @options = {
+        :user => account,
+        :password => password,
+        :headers => {:content_type => 'application/json'},
+      }
+    end
+
+    def call address, options = {}
+      options = options.dup
+
+      args = {}
+      if channel = options.delete(:channel)
+        args[:channel] = channel
+      else
+        args[:channel] = @default_channel
+      end
+
+      args[:address] = address
+
+      if not_before = options.delete(:not_before)
+        args[:not_before] = not_before.iso8601
+      end
+
+      flow = options.delete(:flow)
+      callback_url = options.delete(:callback_url)
+
+      args.merge!(options)
+
+      if flow
+        post "/api/call?#{to_query args}", flow do |response, error|
+          raise ::Pigeon::VerboiceException.new error.message if error
+          JSON.parse response.body
+        end
+      else
+        args[:callback_url] = callback_url if callback_url
+        get_json "/api/call?#{to_query args}"
+      end
+    end
+
+    def call_state id
+      get_json "/api/calls/#{id}/state"
+    end
+
+    def call_redirect id
+      get_json "/api/calls/#{id}/redirect"
+    end
+
+    def channel(name)
+      get("/api/channels/#{name}.json") do |response, error|
+        handle_channel_error error if error
+
+        channel = JSON.parse response.body
+        with_indifferent_access channel
+      end
+    end
+
+    def create_channel(channel)
+      post "/api/channels.json", channel.to_json do |response, error|
+        handle_channel_error error if error
+
+        channel = JSON.parse response.body
+        with_indifferent_access channel
+      end
+    end
+
+    def update_channel(channel, name = channel['name'])
+      put "/api/channels/#{name}.json", channel.to_json do |response, error|
+        handle_channel_error error if error
+
+        channel = JSON.parse response.body
+        with_indifferent_access channel
+      end
+    end
+
+    # Deletes a channel given its name.
+    #
+    # Raises Verboice::Exception if something goes wrong.
+    def delete_channel(name)
+      delete "/api/channels/#{name}" do |response, error|
+        raise ::Pigeon::VerboiceException.new error.message if error
+
+        response
+      end
+    end
+
+    def list_channels()
+      get_json "/api/channels.json"
+    end
+
+    def schedules(project_id)
+      get_json "/api/projects/#{project_id}/schedules.json"
+    end
+
+    def schedule(project_id, name)
+      get_json "/api/projects/#{project_id}/schedules/#{name}.json"
+    end
+
+    def create_schedule(project_id, schedule)
+      post "/api/projects/#{project_id}/schedules", schedule.to_json do |response, error|
+        raise ::Pigeon::VerboiceException.new error.message if error
+        response
+      end
+    end
+
+    def update_schedule(project_id, name, schedule)
+      put "/api/projects/#{project_id}/schedules/#{name}", schedule.to_json do |response, error|
+        raise ::Pigeon::VerboiceException.new error.message if error
+        response
+      end
+    end
+
+    def delete_schedule(project_id, name)
+      delete "/api/projects/#{project_id}/schedules/#{name}" do |response, error|
+        raise ::Pigeon::VerboiceException.new error.message if error
+        response
+      end
+    end
 
-    Verboice.new config.verboice_host, config.verboice_account, config.verboice_password
   end
 end
 

data/lib/pigeon/version.rb

@@ -1,3 +1,3 @@
 module Pigeon
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/pigeon.gemspec

@@ -12,10 +12,10 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{This gem handles creating, updating and destroying channels in Nuntium and Verboice for your Rails application.}
   gem.homepage      = "https://bitbucket.org/instedd/pigeon"
 
-  gem.add_dependency 'rails', '~> 3.2.12'
-  gem.add_dependency 'nuntium_api', '~> 0.19'
-  gem.add_dependency 'verboice', '0.7.0'
+  gem.add_dependency 'rails', '~> 3.2'
   gem.add_dependency 'twitter_oauth'
+  gem.add_dependency 'rest-client'
+  gem.add_dependency 'json'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/lib/pigeon/nuntium_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+module Pigeon
+  describe Nuntium do
+    let(:url) { "http://example.com" }
+    let(:options) { {:user => "account/application", :password => "password", :headers => {:content_type => 'application/json'}} }
+    let(:api) { Nuntium.new url, "account", "application", "password" }
+
+    it "gets countries" do
+      should_receive_http_get '/api/countries.json', %([{"name": "Argentina", "iso2": "ar"}])
+
+      api.countries.should eq(['name' => 'Argentina', 'iso2' => 'ar'])
+    end
+
+    it "gets country" do
+      should_receive_http_get '/api/countries/ar.json', %({"name": "Argentina", "iso2": "ar"})
+
+      api.country('ar').should eq({'name' => 'Argentina', 'iso2' => 'ar'})
+    end
+
+    it "gets carriers" do
+      should_receive_http_get '/api/carriers.json', %([{"name": "Argentina", "iso2": "ar"}])
+
+      api.carriers.should eq(['name' => 'Argentina', 'iso2' => 'ar'])
+    end
+
+    it "gets carriers for a country" do
+      should_receive_http_get '/api/carriers.json?country_id=ar', %([{"name": "Argentina", "iso2": "ar"}])
+
+      api.carriers('ar').should eq(['name' => 'Argentina', 'iso2' => 'ar'])
+    end
+
+    it "gets carrier" do
+      should_receive_http_get '/api/carriers/ar.json', %({"name": "Argentina", "iso2": "ar"})
+
+      api.carrier('ar').should eq({'name' => 'Argentina', 'iso2' => 'ar'})
+    end
+
+    it "gets channels" do
+      should_receive_http_get '/api/channels.json', %([{"name": "Argentina", "configuration": [{"name": "foo", "value": "bar"}]}])
+
+      api.channels.should eq([{'name' => 'Argentina', 'configuration' => {'foo' => 'bar'}}])
+    end
+
+    it "gets channel" do
+      should_receive_http_get '/api/channels/Argentina.json', %({"name": "Argentina", "configuration": [{"name": "foo", "value": "bar"}]})
+
+      api.channel('Argentina').should eq({'name' => 'Argentina', 'configuration' => {'foo' => 'bar'}})
+    end
+
+    it "creates channel" do
+      channel_json = %({"name":"Argentina","configuration":[{"name":"foo","value":"bar"}]})
+      should_receive_http_post '/api/channels.json', channel_json, channel_json
+
+      channel = {'name' => 'Argentina', 'configuration' => {'foo' => 'bar'}}
+
+      api.create_channel(channel).should eq(channel)
+    end
+
+    it "updates channel", :focus => true do
+      channel_json = %({"name":"Argentina","configuration":[{"name":"foo","value":"bar"}]})
+      should_receive_http_put '/api/channels/Argentina.json', channel_json, channel_json
+
+      channel = {'name' => 'Argentina', 'configuration' => {'foo' => 'bar'}}
+
+      api.update_channel(channel).should eq(channel)
+    end
+
+    it "deletes channel", :focus => true do
+      should_receive_http_delete '/api/channels/Argentina'
+
+      api.delete_channel('Argentina')
+    end
+
+    it "gets candidate channels for ao", :focus => true do
+      should_receive_http_get "/api/candidate/channels.json?from=#{CGI.escape 'sms://1234'}&body=Hello", %([{"name":"Argentina","configuration":[{"value":"bar","name":"foo"}]}])
+
+      channels = api.candidate_channels_for_ao :from => 'sms://1234', :body => 'Hello'
+      channels.should eq([{'name' => 'Argentina', 'configuration' => {'foo' => 'bar'}}])
+    end
+
+    it "sends single ao" do
+      should_receive_http_get_with_headers "/account/application/send_ao?from=#{CGI.escape 'sms://1234'}&body=Hello", :x_nuntium_id => '1', :x_nuntium_guid => '2', :x_nuntium_token => '3'
+      response = api.send_ao :from => 'sms://1234', :body => 'Hello'
+      response.should eq("id" => '1', "guid" => '2', "token" => '3')
+    end
+
+    it "sends many aos" do
+      post_body = %([{"from":"sms://1234","body":"Hello"}])
+      should_receive_http_post_with_headers "/account/application/send_ao.json", post_body, :x_nuntium_token => '3'
+      response = api.send_ao [{:from => 'sms://1234', :body => 'Hello'}]
+      response.should eq("token" => '3')
+    end
+
+    it "gets ao" do
+      should_receive_http_get '/account/application/get_ao.json?token=foo', %([{"name": "Argentina", "iso2": "ar"}])
+
+      api.get_ao('foo').should eq([{'name' => 'Argentina', 'iso2' => 'ar'}])
+    end
+
+    it "gets custom attributes" do
+      should_receive_http_get '/api/custom_attributes?address=foo', %([{"name": "Argentina", "iso2": "ar"}])
+
+      api.get_custom_attributes('foo').should eq([{'name' => 'Argentina', 'iso2' => 'ar'}])
+    end
+
+    it "sets custom attributes" do
+      should_receive_http_post '/api/custom_attributes?address=foo', %({"application":"bar"}), ''
+
+      api.set_custom_attributes('foo', :application => :bar)
+    end
+
+    it "creates twitter friendship" do
+      should_receive_http_get '/api/channels/twit/twitter/friendships/create?user=foo&follow=true'
+
+      api.twitter_friendship_create 'twit', 'foo', true
+    end
+
+    it "authorizes twitter channel" do
+      should_receive_http_get '/api/channels/twit/twitter/authorize?callback=foo', "http://bar"
+
+      url = api.twitter_authorize 'twit', 'foo'
+      url.should eq("http://bar")
+    end
+
+    it "adds xmpp contact" do
+      should_receive_http_get "/api/channels/chan/xmpp/add_contact?jid=#{CGI.escape 'foo@bar.com'}"
+
+      api.xmpp_add_contact 'chan', 'foo@bar.com'
+    end
+
+    def should_receive_http_get(path, body = nil)
+      resource = mock 'resource'
+      RestClient::Resource.should_receive(:new).with(url, options).and_return(resource)
+
+      resource2 = mock 'resource2'
+      resource.should_receive(:[]).with(path).and_return(resource2)
+
+      resource3 = mock 'resource3'
+      resource2.should_receive(:get).and_return(resource3)
+
+      resource3.should_receive(:body).and_return(body) if body
+    end
+
+    def should_receive_http_get_with_headers(path, headers)
+      resource = mock 'resource'
+      RestClient::Resource.should_receive(:new).with(url, options).and_return(resource)
+
+      resource2 = mock 'resource2'
+      resource.should_receive(:[]).with(path).and_return(resource2)
+
+      resource3 = mock 'resource3'
+      resource2.should_receive(:get).and_return(resource3)
+
+      resource3.stub(:headers) { headers }
+    end
+
+    def should_receive_http_post(path, data, body)
+      resource = mock 'resource'
+      RestClient::Resource.should_receive(:new).with(url, options).and_return(resource)
+
+      resource2 = mock 'resource2'
+      resource.should_receive(:[]).with(path).and_return(resource2)
+
+      resource3 = mock 'resource3'
+      resource2.should_receive(:post).with(data).and_return(resource3)
+
+      resource3.stub(:body) { body }
+    end
+
+    def should_receive_http_post_with_headers(path, data, headers)
+      resource = mock 'resource'
+      RestClient::Resource.should_receive(:new).with(url, options).and_return(resource)
+
+      resource2 = mock 'resource2'
+      resource.should_receive(:[]).with(path).and_return(resource2)
+
+      resource3 = mock 'resource3'
+      resource2.should_receive(:post).with(data).and_return(resource3)
+
+      resource3.stub(:headers) { headers }
+    end
+
+    def should_receive_http_put(path, data, body)
+      resource = mock 'resource'
+      RestClient::Resource.should_receive(:new).with(url, options).and_return(resource)
+
+      resource2 = mock 'resource2'
+      resource.should_receive(:[]).with(path).and_return(resource2)
+
+      resource3 = mock 'resource3'
+      resource2.should_receive(:put).with(data).and_return(resource3)
+
+      resource3.should_receive(:body).and_return(body)
+    end
+
+    def should_receive_http_delete(path)
+      resource = mock 'resource'
+      RestClient::Resource.should_receive(:new).with(url, options).and_return(resource)
+
+      resource2 = mock 'resource2'
+      resource.should_receive(:[]).with(path).and_return(resource2)
+
+      resource3 = mock 'resource3'
+      resource2.should_receive(:delete)
+    end
+  end
+end