nexmo 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae52a9612e17e4e82d62b525f27b1d02523f6d34
-  data.tar.gz: e0fb13b7e0989a6f591102ff5583120006df6270
+  metadata.gz: 47f16f5764c3fe417e459938495ca477c35fe795
+  data.tar.gz: ff55281f11a6bde0f430d0b532105055f4e11d81
 SHA512:
-  metadata.gz: a9bbfbdf2791eff805283d71bad2812a0900b8e6afee3104e6387136112fe5d303f0557f2a35e09165e57a9e1ab7b693ccea95b7b07c8c79bafaed070be50fc1
-  data.tar.gz: dc9656dd961d47e4a908077f0fb1b80f1b7fac12f4d410c75b7495f3a10b3ce1f7ee215e1f02c971f80dd6bf5ba529e7ca2fa4e40fc4f4e84ef443144c0cf645
+  metadata.gz: fbe03e55277356116df31c26682b2c0ba77adb28e34c854d6f9b7324095add975100e5ad527fa1f74e02e38c0669d78560939813537089c2f7409489001bd62d
+  data.tar.gz: 5fc3ff3f2db8e057f92d8910e2a4821319f5c61c0c3fa7b21cfdb3ab73457a8e9a518487ce33616e44f32f385a11476ff0ff1fec8b0d010f13a9fb9c754b2b8e

data/README.md

@@ -11,99 +11,34 @@ Installation
     $ gem install nexmo
 
 
-Quick start (sending a message)
--------------------------------
+Sending a message
+-----------------
 
-First you need to load up the gem and construct a Nexmo::Client object
-with your API credentials, like this:
+Construct a Nexmo::Client object and use the #send_message method to
+send a message. For example:
 
 ```ruby
 require 'nexmo'
 
-nexmo = Nexmo::Client.new('...API KEY...', '...API SECRET...')
-```
-
-Then you have a choice. For a "fire and forget" approach to sending a message,
-use the `send_message!` method, like this:
+nexmo = Nexmo::Client.new(key: 'YOUR API KEY', secret: 'YOUR API SECRET')
 
-```ruby
-nexmo.send_message!({:to => '...NUMBER...', :from => 'Ruby', :text => 'Hello world'})
+nexmo.send_message(from: 'Ruby', to: 'YOUR NUMBER', text: 'Hello world')
 ```
 
 This method call returns the message id if the message was sent successfully,
-or raises an exception if there was an error. If you need more robust error
-handling use the `send_message` method instead, like this:
-
-```ruby
-response = nexmo.send_message({:to => '...NUMBER...', :from => 'Ruby', :text => 'Hello world'})
-
-if response.ok?
-  # do something with response.object
-else
-  # handle the error
-end
-```
+or raises an exception if there was an error. The Nexmo documentation contains
+a [list of error codes](https://docs.nexmo.com/index.php/sms-api/send-message#response_code)
+which may be useful for debugging exceptions.
 
-This method call returns a `Nexmo::Response` object, which wraps the underlying
-Net::HTTP response and adds a few convenience methods. Additional methods are
-also provided for managing your account and messages.
 
-
-Authenticating with OAuth (beta)
+Production environment variables
 --------------------------------
 
-If you are building an app that needs access to Nexmo resources on behalf of
-other accounts then you will want to use OAuth to authenticate your requests.
-Authorizing access and fetching access tokens can be achieved using the
-[oauth gem](http://rubygems.org/gems/oauth) directly. You can then use an
-OAuth::AccessToken object together with a Nexmo::Client object to make calls
-to the API that are authenticated using OAuth. For example:
-
-```ruby
-require 'nexmo'
-require 'oauth'
-
-nexmo = Nexmo::Client.new
-nexmo.oauth_access_token = OAuth::AccessToken.new(consumer, token, secret)
-
-response = nexmo.get_balance
-
-if response.ok?
-  # do something with response.object
-else
-  # handle the error
-end
-```
-
-The OAuth::Consumer object should be pointed at `rest.nexmo.com` with the `:scheme` option set to `:header`, like this:
-
-```ruby
-OAuth::Consumer.new(consumer_key, consumer_secret, {
-  :site => 'https://rest.nexmo.com',
-  :scheme => :header
-})
-```
-
-Using the `:body` or `:query_string` authorization mechanisms is not supported.
-
-
-Custom response behaviour
--------------------------
-
-You can customise the response handling by passing a block when constructing
-a Nexmo::Client object. For example, if you want to use an alternative JSON
-implementation to decode response bodies, you could do this:
-
-```ruby
-nexmo = Nexmo::Client.new do |response|
-  response.object = MultiJson.load(response.body) if response.ok? && response.json?
-  response
-end
-```
-
-This might also be useful if you prefer a different style of error handling
-(e.g. raising exceptions on error and returning the response object directly
-for 200 OK responses), if you need to log responses etc.
+Best practice for storing credentials for external services in production is
+to use environment variables, as described by [12factor.net/config](http://12factor.net/config).
+Nexmo::Client defaults to extracting the api key/secret it needs from the
+NEXMO_API_KEY and NEXMO_API_SECRET environment variables if the key/secret
+options were not specified explicitly.
 
 
 Troubleshooting
@@ -111,7 +46,4 @@ Troubleshooting
 
 Remember that phone numbers should be specified in international format.
 
-The Nexmo documentation contains a [list of error codes](https://docs.nexmo.com/index.php/sms-api/send-message#response_code)
-which may be useful if you have problems sending a message.
-
 Please report all bugs/issues via the GitHub issue tracker.

data/lib/nexmo.rb

@@ -1,20 +1,19 @@
 require 'net/http'
-require 'net/https' if RUBY_VERSION == '1.8.7'
 require 'json'
 require 'cgi'
 
 module Nexmo
+  class Error < StandardError; end
+
+  class AuthenticationError < Error; end
+
   class Client
-    def initialize(key = ENV['NEXMO_API_KEY'], secret = ENV['NEXMO_API_SECRET'], options = {}, &block)
-      @key, @secret, @block = key, secret, block
+    attr_accessor :key, :secret, :http
 
-      if options.has_key?(:json)
-        Kernel.warn '[nexmo] :json option is deprecated'
+    def initialize(options = {})
+      @key = options.fetch(:key) { ENV.fetch('NEXMO_API_KEY') }
 
-        @json = options[:json]
-      else
-        @json = JSON
-      end
+      @secret = options.fetch(:secret) { ENV.fetch('NEXMO_API_SECRET') }
 
       @host = options.fetch(:host) { 'rest.nexmo.com' }
 
@@ -23,27 +22,17 @@ module Nexmo
       @http.use_ssl = true
     end
 
-    attr_accessor :key, :secret, :http, :oauth_access_token
-
     def send_message(params)
-      post('/sms/json', params)
-    end
-
-    def send_message!(params)
-      response = send_message(params)
+      response = post('/sms/json', params)
 
-      if response.ok? && response.json?
-        item = response.object['messages'].first
+      item = response['messages'].first
 
-        status = item['status'].to_i
+      status = item['status'].to_i
 
-        if status == 0
-          item['message-id']
-        else
-          raise Error, "#{item['error-text']} (status=#{status})"
-        end
+      if status == 0
+        item['message-id']
       else
-        raise Error, "Unexpected HTTP response (code=#{response.code})"
+        raise Error, "#{item['error-text']} (status=#{status})"
       end
     end
 
@@ -91,32 +80,63 @@ module Nexmo
       get('/search/messages', Hash === params ? params : {:ids => Array(params)})
     end
 
+    def send_ussd_push_message(params)
+      post('/ussd/json', params)
+    end
+
+    def send_ussd_prompt_message(params)
+      post('/ussd-prompt/json', params)
+    end
+
+    def send_2fa_message(params)
+      post('/sc/us/2fa/json', params)
+    end
+
+    def send_event_alert_message(params)
+      post('/sc/us/alert/json', params)
+    end
+
+    def send_marketing_message(params)
+      post('/sc/us/marketing/json', params)
+    end
+
+    def initiate_call(params)
+      post('/call/json', params)
+    end
+
+    def initiate_tts_call(params)
+      post('/tts/json', params)
+    end
+
+    def initiate_tts_prompt_call(params)
+      post('/tts-prompt/json', params)
+    end
+
     private
 
     def get(path, params = {})
-      http_response = if oauth_access_token
-        oauth_access_token.get(request_uri(path, params))
-      else
-        @http.get(request_uri(path, params.merge(:api_key => @key, :api_secret => @secret)))
-      end
-
-      decode(http_response)
+      parse @http.get(request_uri(path, params.merge(:api_key => @key, :api_secret => @secret)))
     end
 
     def post(path, params)
-      http_response = if oauth_access_token
-        oauth_access_token.post(path, @json.dump(params), {'Content-Type' => 'application/json'})
-      else
-        @http.post(path, @json.dump(params.merge(:api_key => @key, :api_secret => @secret)), {'Content-Type' => 'application/json'})
-      end
+      body = URI.encode_www_form(params.merge(:api_key => @key, :api_secret => @secret))
 
-      decode(http_response)
+      parse @http.post(path, body, {'Content-Type' => 'application/x-www-form-urlencoded'})
     end
 
-    def decode(http_response)
-      response = Response.new(http_response, :json => @json)
-
-      @block ? @block.call(response) : response
+    def parse(http_response)
+      case http_response
+      when Net::HTTPSuccess
+        if http_response['Content-Type'].split(';').first == 'application/json'
+          JSON.parse(http_response.body)
+        else
+          http_response.body
+        end
+      when Net::HTTPUnauthorized
+        raise AuthenticationError
+      else
+        raise Error, "Unexpected HTTP response (code=#{http_response.code})"
+      end
     end
 
     def request_uri(path, hash = {})
@@ -135,37 +155,4 @@ module Nexmo
       CGI.escape(component.to_s)
     end
   end
-
-  class Response
-    attr_writer :object
-
-    def initialize(http_response, options = {})
-      @http_response = http_response
-
-      @json = options.fetch(:json) { JSON }
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      @http_response.respond_to?(name)
-    end
-
-    def method_missing(name, *args, &block)
-      @http_response.send(name, *args, &block)
-    end
-
-    def ok?
-      code.to_i == 200
-    end
-
-    def json?
-      self['Content-Type'].split(';').first == 'application/json'
-    end
-
-    def object
-      @object ||= @json.parse(body)
-    end
-  end
-
-  class Error < StandardError
-  end
 end

data/nexmo.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'nexmo'
-  s.version = '1.3.0'
+  s.version = '2.0.0'
   s.platform = Gem::Platform::RUBY
   s.authors = ['Tim Craft']
   s.email = ['mail@timcraft.com']
@@ -9,14 +9,6 @@ Gem::Specification.new do |s|
   s.summary = 'See description'
   s.files = Dir.glob('{lib,spec}/**/*') + %w(README.md nexmo.gemspec)
   s.add_development_dependency('rake', '>= 0.9.3')
-  s.add_development_dependency('mocha', '~> 0.13.2')
-  s.add_development_dependency('oauth', '~> 0.4.7')
-  s.add_development_dependency('faux', '~> 1.1.0')
-  s.add_development_dependency('webmock', '~> 1.17.0')
+  s.add_development_dependency('webmock', '~> 1.18.0')
   s.require_path = 'lib'
-
-  if RUBY_VERSION == '1.8.7'
-    s.add_development_dependency('minitest', '~> 4.2.0')
-    s.add_development_dependency('json', '~> 1.8.0')
-  end
 end

data/spec/nexmo_spec.rb

@@ -1,22 +1,24 @@
 require 'minitest/autorun'
 require 'webmock/minitest'
-require 'mocha/setup'
-require 'faux'
 require 'nexmo'
-require 'oauth'
-require 'json'
 
 describe 'Nexmo::Client' do
+  def json_response_body(content)
+    {headers: {'Content-Type' => 'application/json;charset=utf-8'}, body: content}
+  end
+
   before do
     @base_url = 'https://rest.nexmo.com'
 
-    @json_object = {:body => /\{".+?":".+?"(,".+?":".+?")+\}/, :headers => {'Content-Type' => 'application/json'}}
+    @form_urlencoded_data = {body: /(.+?)=(.+?)(&(.+?)=(.+?))+/, headers: {'Content-Type' => 'application/x-www-form-urlencoded'}}
 
-    @oauth_header = {'Authorization' => /\AOAuth .+\z/}
+    @json_response_body = json_response_body('{"key":"value"}')
+
+    @json_response_object = {'key' => 'value'}
 
     @example_message_hash = {:from => 'ruby', :to => 'number', :text => 'Hey!'}
 
-    @client = Nexmo::Client.new('key', 'secret')
+    @client = Nexmo::Client.new(key: 'key', secret: 'secret')
   end
 
   describe 'http method' do
@@ -28,283 +30,238 @@ describe 'Nexmo::Client' do
   end
 
   describe 'send_message method' do
-    it 'posts to the sms json resource and returns a response object' do
-      stub_request(:post, "#@base_url/sms/json").with(@json_object)
-
-      @client.send_message(@example_message_hash).must_be_instance_of(Nexmo::Response)
-    end
-  end
-
-  describe 'send_message bang method' do
-    before do
-      @http_response = stub(:code => '200', :[] => 'application/json;charset=utf-8')
-    end
-
     it 'posts to the sms json resource and returns the message id' do
-      stub_request(:post, "#@base_url/sms/json").with(@json_object).to_return({
-        :headers => {'Content-Type' => 'application/json'},
-        :body => '{"messages":[{"status":0,"message-id":"id"}]}'
-      })
-
-      @client.send_message!(@example_message_hash).must_equal('id')
-    end
+      response_body = json_response_body('{"messages":[{"status":0,"message-id":"id"}]}')
 
-    it 'raises an exception if the response code is not expected' do
-      stub_request(:post, "#@base_url/sms/json").with(@json_object).to_return(:status => 500)
+      stub_request(:post, "#@base_url/sms/json").with(@form_urlencoded_data).to_return(response_body)
 
-      proc { @client.send_message!(@example_message_hash) }.must_raise(Nexmo::Error)
+      @client.send_message(@example_message_hash).must_equal('id')
     end
 
     it 'raises an exception if the response body contains an error' do
-      stub_request(:post, "#@base_url/sms/json").with(@json_object).to_return({
-        :headers => {'Content-Type' => 'application/json'},
-        :body => '{"messages":[{"status":2,"error-text":"Missing from param"}]}'
-      })
+      response_body = json_response_body('{"messages":[{"status":2,"error-text":"Missing from param"}]}')
+
+      stub_request(:post, "#@base_url/sms/json").with(@form_urlencoded_data).to_return(response_body)
 
-      proc { @client.send_message!(@example_message_hash) }.must_raise(Nexmo::Error)
+      exception = proc { @client.send_message(@example_message_hash) }.must_raise(Nexmo::Error)
+
+      exception.message.must_include('Missing from param')
     end
   end
 
   describe 'get_balance method' do
-    it 'fetches the account balance resource and returns a response object' do
-      stub_request(:get, "#@base_url/account/get-balance?api_key=key&api_secret=secret")
+    it 'fetches the account balance resource and returns the response object' do
+      url = "#@base_url/account/get-balance?api_key=key&api_secret=secret"
+
+      stub_request(:get, url).to_return(@json_response_body)
 
-      @client.get_balance.must_be_instance_of(Nexmo::Response)
+      @client.get_balance.must_equal(@json_response_object)
     end
   end
 
   describe 'get_country_pricing method' do
-    it 'fetches the outbound pricing resource for the given country and returns a response object' do
-      stub_request(:get, "#@base_url/account/get-pricing/outbound?api_key=key&api_secret=secret&country=CA")
+    it 'fetches the outbound pricing resource for the given country and returns the response object' do
+      url = "#@base_url/account/get-pricing/outbound?api_key=key&api_secret=secret&country=CA"
+
+      stub_request(:get, url).to_return(@json_response_body)
 
-      @client.get_country_pricing(:CA).must_be_instance_of(Nexmo::Response)
+      @client.get_country_pricing(:CA).must_equal(@json_response_object)
     end
   end
 
   describe 'get_prefix_pricing method' do
-    it 'fetches the outbound pricing resource for the given prefix and returns a response object' do
-      stub_request(:get, "#@base_url/account/get-prefix-pricing/outbound?api_key=key&api_secret=secret&prefix=44")
+    it 'fetches the outbound pricing resource for the given prefix and returns the response object' do
+      url = "#@base_url/account/get-prefix-pricing/outbound?api_key=key&api_secret=secret&prefix=44"
 
-      @client.get_prefix_pricing(44).must_be_instance_of(Nexmo::Response)
+      stub_request(:get, url).to_return(@json_response_body)
+
+      @client.get_prefix_pricing(44).must_equal(@json_response_object)
     end
   end
 
   describe 'get_account_numbers method' do
-    it 'fetches the account numbers resource with the given parameters and returns a response object' do
-      stub_request(:get, "#@base_url/account/numbers?api_key=key&api_secret=secret&size=25&pattern=33")
+    it 'fetches the account numbers resource with the given parameters and returns the response object' do
+      url = "#@base_url/account/numbers?api_key=key&api_secret=secret&size=25&pattern=33"
+
+      stub_request(:get, url).to_return(@json_response_body)
 
-      @client.get_account_numbers(:size => 25, :pattern => 33).must_be_instance_of(Nexmo::Response)
+      @client.get_account_numbers(:size => 25, :pattern => 33).must_equal(@json_response_object)
     end
   end
 
   describe 'number_search method' do
-    it 'fetches the number search resource for the given country with the given parameters and returns a response object' do
-      stub_request(:get, "#@base_url/number/search?api_key=key&api_secret=secret&country=CA&size=25")
+    it 'fetches the number search resource for the given country with the given parameters and returns the response object' do
+      url = "#@base_url/number/search?api_key=key&api_secret=secret&country=CA&size=25"
 
-      @client.number_search(:CA, :size => 25).must_be_instance_of(Nexmo::Response)
+      stub_request(:get, url).to_return(@json_response_body)
+
+      @client.number_search(:CA, :size => 25).must_equal(@json_response_object)
     end
   end
 
   describe 'buy_number method' do
-    it 'purchases the number requested with the given parameters and returns a response object' do
-      stub_request(:post, "#@base_url/number/buy").with(@json_object)
+    it 'purchases the number requested with the given parameters and returns the response object' do
+      url = "#@base_url/number/buy"
+
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @client.buy_number(:country => 'US', :msisdn => 'number').must_be_instance_of(Nexmo::Response)
+      @client.buy_number(:country => 'US', :msisdn => 'number').must_equal(@json_response_object)
     end
   end
 
   describe 'cancel_number method' do
-    it 'cancels the number requested with the given parameters and returns a response object' do
-      stub_request(:post, "#@base_url/number/cancel").with(@json_object)
+    it 'cancels the number requested with the given parameters and returns the response object' do
+      url = "#@base_url/number/cancel"
 
-      @client.cancel_number(:country => 'US', :msisdn => 'number').must_be_instance_of(Nexmo::Response)
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
+
+      @client.cancel_number(:country => 'US', :msisdn => 'number').must_equal(@json_response_object)
     end
   end
 
   describe 'update_number method' do
-    it 'updates the number requested with the given parameters and returns a response object' do
-      stub_request(:post, "#@base_url/number/update").with(@json_object)
+    it 'updates the number requested with the given parameters and returns the response object' do
+      url = "#@base_url/number/update"
+
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @client.update_number(:country => 'US', :msisdn => 'number', :moHttpUrl => 'callback').must_be_instance_of(Nexmo::Response)
+      @client.update_number(:country => 'US', :msisdn => 'number', :moHttpUrl => 'callback').must_equal(@json_response_object)
     end
   end
 
   describe 'get_message method' do
-    it 'fetches the message search resource for the given message id and returns a response object' do
-      stub_request(:get, "#@base_url/search/message?api_key=key&api_secret=secret&id=00A0B0C0")
+    it 'fetches the message search resource for the given message id and returns the response object' do
+      url = "#@base_url/search/message?api_key=key&api_secret=secret&id=00A0B0C0"
 
-      @client.get_message('00A0B0C0').must_be_instance_of(Nexmo::Response)
+      stub_request(:get, url).to_return(@json_response_body)
+
+      @client.get_message('00A0B0C0').must_equal(@json_response_object)
     end
   end
 
   describe 'get_message_rejections method' do
-    it 'fetches the message rejections resource with the given parameters and returns a response object' do
-      stub_request(:get, "#@base_url/search/rejections?api_key=key&api_secret=secret&date=YYYY-MM-DD")
+    it 'fetches the message rejections resource with the given parameters and returns the response object' do
+      url = "#@base_url/search/rejections?api_key=key&api_secret=secret&date=YYYY-MM-DD"
+
+      stub_request(:get, url).to_return(@json_response_body)
 
-      @client.get_message_rejections(:date => 'YYYY-MM-DD').must_be_instance_of(Nexmo::Response)
+      @client.get_message_rejections(:date => 'YYYY-MM-DD').must_equal(@json_response_object)
     end
   end
 
   describe 'search_messages method' do
-    it 'fetches the search messages resource with the given parameters and returns a response object' do
-      stub_request(:get, "#@base_url/search/messages?api_key=key&api_secret=secret&date=YYYY-MM-DD&to=1234567890")
+    it 'fetches the search messages resource with the given parameters and returns the response object' do
+      url = "#@base_url/search/messages?api_key=key&api_secret=secret&date=YYYY-MM-DD&to=1234567890"
 
-      @client.search_messages(:date => 'YYYY-MM-DD', :to => 1234567890).must_be_instance_of(Nexmo::Response)
+      stub_request(:get, url).to_return(@json_response_body)
+
+      @client.search_messages(:date => 'YYYY-MM-DD', :to => 1234567890).must_equal(@json_response_object)
     end
 
     it 'should encode a non hash argument as a list of ids' do
-      stub_request(:get, "#@base_url/search/messages?api_key=key&api_secret=secret&ids=id1&ids=id2")
+      url = "#@base_url/search/messages?api_key=key&api_secret=secret&ids=id1&ids=id2"
+
+      stub_request(:get, url).to_return(@json_response_body)
 
       @client.search_messages(%w(id1 id2))
     end
   end
 
-  describe 'when initialized with an oauth access token' do
-    before do
-      @oauth_consumer = OAuth::Consumer.new('key', 'secret', {:site => 'https://rest.nexmo.com', :scheme => :header})
+  describe 'send_ussd_push_message method' do
+    it 'posts to the ussd json resource and returns the response object' do
+      url = "#@base_url/ussd/json"
 
-      @oauth_access_token = OAuth::AccessToken.new(@oauth_consumer, 'access_token', 'access_token_secret')
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @client = Nexmo::Client.new
-
-      @client.oauth_access_token = @oauth_access_token
-    end
-
-    it 'makes get requests through the access token and returns a response object' do
-      stub_request(:get, "#@base_url/account/get-pricing/outbound?country=CA").with(:headers => @oauth_header)
-
-      @client.get_country_pricing(:CA).must_be_instance_of(Nexmo::Response)
+      @client.send_ussd_push_message(from: 'MyCompany20', to: '447525856424', text: 'Hello')
     end
+  end
 
-    it 'makes post requests through the access token and returns a response object' do
-      @json_object[:headers].merge!(@oauth_header)
+  describe 'send_ussd_prompt_message method' do
+    it 'posts to the ussd prompt json resource and returns the response object' do
+      url = "#@base_url/ussd-prompt/json"
 
-      stub_request(:post, "#@base_url/sms/json").with(@json_object)
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @client.send_message(@example_message_hash).must_be_instance_of(Nexmo::Response)
+      @client.send_ussd_prompt_message(from: 'Nexmo long virtual number', to: '447525856424', text: 'Hello')
     end
   end
 
-  describe 'when initialized with a different json implementation' do
-    it 'emits a deprecation warning' do
-      Kernel.expects(:warn).with(regexp_matches(/:json option is deprecated/))
+  describe 'send_2fa_message method' do
+    it 'posts to the short code two factor authentication json resource and returns the response object' do
+      url = "#@base_url/sc/us/2fa/json"
 
-      @client = Nexmo::Client.new('key', 'secret', :json => stub)
-    end
-
-    describe 'send_message method' do
-      it 'encodes the request body using the alternative json implementation' do
-        Kernel.stubs(:warn)
-
-        @json = faux(JSON)
-
-        @json.expects(:dump).with(instance_of(Hash))
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-        @client = Nexmo::Client.new('key', 'secret', :json => @json)
-
-        @client.http.stubs(:post)
-
-        @client.send_message(@example_message_hash)
-      end
+      @client.send_2fa_message(to: '16365553226', pin: 1234)
     end
   end
 
-  describe 'when initialized with a block' do
-    it 'calls the block for each response and returns the return value of the block' do
-      @client = Nexmo::Client.new('key', 'secret') do |response|
-        response.must_be_instance_of(Nexmo::Response)
+  describe 'send_event_alert_message method' do
+    it 'posts to the short code alert json resource and returns the response object' do
+      url = "#@base_url/sc/us/alert/json"
 
-        :return_value
-      end
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @client.http.stubs(:get).returns(stub)
-
-      @client.get_balance.must_equal(:return_value)
+      @client.send_event_alert_message(to: '16365553226', server: 'host', link: 'http://example.com/')
     end
   end
 
-  it 'provides an option for specifying a different hostname to connect to' do
-    @client = Nexmo::Client.new('key', 'secret', host: 'rest-sandbox.nexmo.com')
-
-    @client.http.address.must_equal('rest-sandbox.nexmo.com')
-  end
-end
-
-describe 'Nexmo::Response' do
-  before do
-    @http_response = mock()
-
-    @response = Nexmo::Response.new(@http_response)
-  end
+  describe 'send_marketing_message method' do
+    it 'posts to the short code marketing json resource and returns the response object' do
+      url = "#@base_url/sc/us/marketing/json"
 
-  it 'delegates to the underlying http response' do
-    @http_response.expects(:code).returns('200')
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-    @response.must_respond_to(:code) unless RUBY_VERSION == '1.8.7'
-    @response.code.must_equal('200')
+      @client.send_marketing_message(from: '666', to: '16365553226', keyword: 'NEXMO', text: 'Hello')
+    end
   end
 
-  describe 'ok query method' do
-    it 'returns true if the status code is 200' do
-      @http_response.expects(:code).returns('200')
-
-      @response.ok?.must_equal(true)
-    end
+  describe 'initiate_call method' do
+    it 'posts to the call json resource and returns the response object' do
+      url = "#@base_url/call/json"
 
-    it 'returns false otherwise' do
-      @http_response.expects(:code).returns('400')
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @response.ok?.must_equal(false)
+      @client.initiate_call(to: '16365553226', answer_url: 'http://example.com/answer')
     end
   end
 
-  describe 'json query method' do
-    it 'returns true if the response has a json content type' do
-      @http_response.expects(:[]).with('Content-Type').returns('application/json;charset=utf-8')
+  describe 'initiate_tts_call method' do
+    it 'posts to the tts json resource and returns the response object' do
+      url = "#@base_url/tts/json"
 
-      @response.json?.must_equal(true)
-    end
-
-    it 'returns false otherwise' do
-      @http_response.expects(:[]).with('Content-Type').returns('text/html')
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
 
-      @response.json?.must_equal(false)
+      @client.initiate_tts_call(to: '16365553226', text: 'Hello')
     end
   end
 
-  describe 'object method' do
-    it 'decodes the response body as json and returns a hash' do
-      @http_response.expects(:body).returns('{"value":0.0}')
+  describe 'initiate_tts_prompt_call method' do
+    it 'posts to the tts prompt json resource and returns the response object' do
+      url = "#@base_url/tts-prompt/json"
 
-      @response.object.must_equal({'value' => 0})
+      stub_request(:post, url).with(@form_urlencoded_data).to_return(@json_response_body)
+
+      @client.initiate_tts_prompt_call(to: '16365553226', text: 'Hello', max_digits: 4, bye_text: 'Goodbye')
     end
   end
 
-  describe 'object equals method' do
-    it 'sets the object to be returned by the object method' do
-      @object = stub
-
-      @response.object = @object
+  it 'raises an exception if the response code is not 2xx' do
+    stub_request(:post, "#@base_url/sms/json").with(@form_urlencoded_data).to_return(status: 500)
 
-      @response.object.must_equal(@object)
-    end
+    proc { @client.send_message(@example_message_hash) }.must_raise(Nexmo::Error)
   end
 
-  describe 'when initialized with a different json implementation' do
-    before do
-      @json = faux(JSON)
-
-      @response = Nexmo::Response.new(@http_response, :json => @json)
-    end
+  it 'raises an authentication error exception if the response code is 401' do
+    stub_request(:post, "#@base_url/sms/json").with(@form_urlencoded_data).to_return(status: 401)
 
-    describe 'object method' do
-      it 'decodes the response body using the alternative json implementation' do
-        @json.expects(:parse).with('{"value":0.0}')
+    proc { @client.send_message(@example_message_hash) }.must_raise(Nexmo::AuthenticationError)
+  end
 
-        @http_response.stubs(:body).returns('{"value":0.0}')
+  it 'provides an option for specifying a different hostname to connect to' do
+    @client = Nexmo::Client.new(key: 'key', secret: 'secret', host: 'rest-sandbox.nexmo.com')
 
-        @response.object
-      end
-    end
+    @client.http.address.must_equal('rest-sandbox.nexmo.com')
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexmo
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Tim Craft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-22 00:00:00.000000000 Z
+date: 2014-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,62 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.3
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.13.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.13.2
-- !ruby/object:Gem::Dependency
-  name: oauth
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.7
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.7
-- !ruby/object:Gem::Dependency
-  name: faux
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.17.0
+        version: 1.18.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.17.0
+        version: 1.18.0
 description: A Ruby wrapper for the Nexmo API
 email:
 - mail@timcraft.com