nexmos 0.2 → 0.3

data/lib/nexmos/railties.rb

@@ -4,4 +4,4 @@ module Nexmos
       ::Nexmos.logger = Rails.logger
     end
   end
-end
+end

data/lib/nexmos/search.rb

@@ -1,5 +1,5 @@
 module Nexmos
   class Search < Base
-    self.define_api_calls(:search)
+    define_api_calls(:search)
   end
-end
+end

data/lib/nexmos/text_to_speech.rb

@@ -1,5 +1,5 @@
 module Nexmos
   class TextToSpeech < Base
-    self.define_api_calls(:text_to_speech)
+    define_api_calls(:text_to_speech)
   end
-end
+end

data/lib/nexmos/version.rb

@@ -1,3 +1,3 @@
 module Nexmos
-  VERSION = "0.2"
+  VERSION = '0.3'
 end

data/nexmos.gemspec

@@ -15,10 +15,10 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  gem.add_dependency('rash')
+  gem.add_dependency('hashie', '>= 2.1.0')
   gem.add_dependency('faraday')
   gem.add_dependency('faraday_middleware')
-  gem.add_dependency('activesupport', '>= 3.0.0')
-  gem.add_development_dependency('rspec')
+  gem.add_dependency('activesupport', '>= 3.0', '<= 5.0')
+  gem.add_development_dependency('rspec', '>= 3.0')
   gem.add_development_dependency('webmock')
 end

data/spec/nexmos/account_spec.rb

@@ -45,7 +45,7 @@ describe ::Nexmos::Account do
               "ranges" => ["35846", "35850"],
               "mtPrice" => "0.05000000"}],
         "name" => "Finland"
-    }
+    }.to_json
   end
 
   let(:prefix_prices) do
@@ -80,7 +80,7 @@ describe ::Nexmos::Account do
              "ranges" => nil,
              "mtPrice" => "0.05000000"}],
          "name" => "Finland"}],
-     }
+     }.to_json
   end
 
   before(:each) do
@@ -97,11 +97,11 @@ describe ::Nexmos::Account do
 
     it 'should return value' do
       request = stub_request(:get, "https://rest.nexmo.com/account/get-balance?api_key=default_key&api_secret=default_secret").
-          with(webmock_default_headers).to_return(:status => 200, :body => {"value" => 4.107}, :headers => {})
+          with(webmock_default_headers).to_return(:status => 200, :body => {"value" => 4.107}.to_json, headers: {'Content-Type' => 'application/json'})
       res = subject.get_balance
-      res.should be_kind_of(::Hash)
-      res.value.should == 4.107
-      request.should have_been_made.once
+      expect(res).to be_kind_of(::Hash)
+      expect(res.value).to eq(4.107)
+      expect(request).to have_been_made.once
     end
   end
 
@@ -112,15 +112,15 @@ describe ::Nexmos::Account do
 
     it 'should be success' do
       request = stub_request(:get, "https://rest.nexmo.com/account/get-pricing/outbound?api_key=default_key&api_secret=default_secret&country=FI").
-          with(webmock_default_headers).to_return(:status => 200, :body => finland_prices, :headers => {})
+          with(webmock_default_headers).to_return(:status => 200, :body => finland_prices, :headers => {'Content-Type' => 'application/json'})
       res = subject.get_pricing(:country => 'FI')
-      res.should be_kind_of(::Hash)
-      res.success?.should be_true
-      res.country.should == 'FI'
-      res.keys.sort.should == %w(country name prefix mt networks success?).sort
-      res.networks.should be_kind_of(::Array)
-      res.networks[0].keys.sort.should == %w(code network mt_price ranges).sort
-      request.should have_been_made.once
+      expect(res).to be_kind_of(::Hash)
+      expect(res.success?).to be_truthy
+      expect(res.country).to eq('FI')
+      expect(res.keys.sort).to eq(%w(country name prefix mt networks success?).sort)
+      expect(res.networks).to be_kind_of(::Array)
+      expect(res.networks[0].keys.sort).to eq(%w(code network mt_price ranges).sort)
+      expect(request).to have_been_made.once
     end
   end
 
@@ -131,41 +131,47 @@ describe ::Nexmos::Account do
 
     it 'should be success' do
       request = stub_request(:get, "https://rest.nexmo.com/account/get-prefix-pricing/outbound?api_key=default_key&api_secret=default_secret&prefix=358").
-          with(webmock_default_headers).to_return(:status => 200, :body => prefix_prices, :headers => {})
+          with(webmock_default_headers).to_return(:status => 200, :body => prefix_prices, :headers => {'Content-Type' => 'application/json'})
       res = subject.get_prefix_pricing(:prefix => '358')
-      res.should be_kind_of(::Hash)
-      res.success?.should be_true
-      res.keys.sort.should == %w(count prices success?).sort
-      res.prices.should be_kind_of(::Array)
-      res.prices[0].keys.sort.should == %w(country name prefix mt networks).sort
-      res.prices[0].networks.should be_kind_of(::Array)
-      res.prices[0].networks[0].keys.sort.should == %w(code network mt_price ranges).sort
-      request.should have_been_made.once
+      expect(res).to be_kind_of(::Hash)
+      expect(res.success?).to be_truthy
+      expect(res.keys.sort).to eq(%w(count prices success?).sort)
+      expect(res.prices).to be_kind_of(::Array)
+      expect(res.prices[0].keys.sort).to eq(%w(country name prefix mt networks).sort)
+      expect(res.prices[0].networks).to be_kind_of(::Array)
+      expect(res.prices[0].networks[0].keys.sort).to eq(%w(code network mt_price ranges).sort)
+      expect(request).to have_been_made.once
     end
   end
 
   context '#get_numbers' do
     it 'should return only count on empty numbers' do
       request = stub_request(:get, "https://rest.nexmo.com/account/numbers?api_key=default_key&api_secret=default_secret").
-          with(webmock_default_headers).to_return(:status => 200, :body => {:count => 0}, :headers => {})
+          with(webmock_default_headers).to_return(:status => 200, :body => {:count => 0}.to_json, :headers => {'Content-Type' => 'application/json'})
       res = subject.get_numbers
-      res.should be_kind_of(::Hash)
-      res.success?.should be_true
-      res['count'].should == 0
-      request.should have_been_made.once
+      expect(res).to be_kind_of(::Hash)
+      expect(res.success?).to be_truthy
+      expect(res['count']).to eq(0)
+      expect(request).to have_been_made.once
     end
 
     it 'should return numbers array' do
       request = stub_request(:get, "https://rest.nexmo.com/account/numbers?api_key=default_key&api_secret=default_secret").
-          with(webmock_default_headers).to_return(:status => 200, :body => { "count" => 1,"numbers" => [{"country" => "ES","msisdn" => "34911067000","type" => "landline"}]}, :headers => {})
+          with(webmock_default_headers).to_return(:status => 200,
+                                                  :body => {
+                                                    "count" => 1,
+                                                    "numbers" => [
+                                                      {"country" => "ES","msisdn" => "34911067000","type" => "landline"}
+                                                    ]
+                                                  }.to_json, :headers => {'Content-Type' => 'application/json'})
       res = subject.get_numbers
-      res.should be_kind_of(::Hash)
-      res.success?.should be_true
-      res['count'].should == 1
-      res['numbers'].should be_kind_of(::Array)
-      res['numbers'].first.should be_kind_of(::Hash)
-      res['numbers'].first.should == {"country" => "ES","msisdn" => "34911067000","type" => "landline"}
-      request.should have_been_made.once
+      expect(res).to be_kind_of(::Hash)
+      expect(res.success?).to be_truthy
+      expect(res['count']).to eq(1)
+      expect(res['numbers']).to be_kind_of(::Array)
+      expect(res['numbers'].first).to be_kind_of(::Hash)
+      expect(res['numbers'].first).to eq({"country" => "ES","msisdn" => "34911067000","type" => "landline"})
+      expect(request).to have_been_made.once
     end
   end
 
@@ -176,11 +182,11 @@ describe ::Nexmos::Account do
 
     it 'should success top up' do
       request = stub_request(:get, "https://rest.nexmo.com/account/top-up?api_key=default_key&api_secret=default_secret&trx=test_trx").
-          with(webmock_default_headers).to_return(:status => 200, :body => '', :headers => {})
+          with(webmock_default_headers).to_return(:status => 200, :body => '', :headers => {'Content-Type' => 'application/json'})
       res = subject.top_up :trx => 'test_trx'
-      res.should be_kind_of(::Hash)
-      res.success?.should be_true
-      request.should have_been_made.once
+      expect(res).to be_kind_of(::Hash)
+      expect(res.success?).to be_truthy
+      expect(request).to have_been_made.once
     end
 
   end

data/spec/nexmos/base_spec.rb

@@ -4,9 +4,9 @@ describe ::Nexmos::Base do
   let(:webmock_default_headers) do
     {
       :headers => {
-        'Accept'=>'application/json',
-        'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
-        'User-Agent'=> ::Nexmos.user_agent
+        'Accept'          => 'application/json',
+        'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+        'User-Agent'      => ::Nexmos.user_agent
       }
     }
   end
@@ -14,20 +14,28 @@ describe ::Nexmos::Base do
   before(:each) do
     ::Nexmos.reset!
   end
+
   context 'class' do
-    subject { ::Nexmos::Base }
+    subject { described_class }
     let(:default_faraday_options) do
       {
-        :url => 'https://rest.nexmo.com',
+        :url     => 'https://rest.nexmo.com',
         :headers => {
-          :accept =>  'application/json',
+          :accept     => 'application/json',
           :user_agent => ::Nexmos.user_agent
         }
       }
     end
 
-    its(:faraday_options) { should == default_faraday_options }
-    its(:connection) { should be_kind_of(::Faraday::Connection) }
+    describe '#faraday_options' do
+      subject { super().faraday_options }
+      it { is_expected.to eq(default_faraday_options) }
+    end
+
+    describe '#connection' do
+      subject { super().connection }
+      it { is_expected.to be_kind_of(::Faraday::Connection) }
+    end
 
     context 'faraday_options' do
       it 'should have custom user agent' do
@@ -35,14 +43,14 @@ describe ::Nexmos::Base do
           c.user_agent = 'test user agent'
         end
         default_faraday_options[:headers][:user_agent] = 'test user agent'
-        subject.faraday_options.should == default_faraday_options
+        expect(subject.faraday_options).to eq(default_faraday_options)
       end
     end
 
     context 'define_api_calls' do
       it 'should call define_method' do
         ::Nexmos.apis[:account].keys.each do |k|
-          subject.should_receive(:define_method).with(k)
+          expect(subject).to receive(:define_method).with(k)
         end
         subject.define_api_calls(:account)
       end
@@ -50,7 +58,7 @@ describe ::Nexmos::Base do
       it 'should define dynamic method and call make_api_call inside' do
         subject.define_api_calls(:account)
         instance = subject.new('test_key', 'test_secret')
-        instance.should_receive(:make_api_call).with(::Nexmos.apis[:account][:get_balance], {})
+        expect(instance).to receive(:make_api_call).with(::Nexmos.apis[:account][:get_balance], {})
         instance.get_balance
       end
     end
@@ -61,140 +69,143 @@ describe ::Nexmos::Base do
     subject { ::Nexmos::Base.new('test_api', 'test_secret') }
     context 'new' do
       it 'should raise on empty api_key' do
-        expect {::Nexmos::Base.new('', 'test_secret')}.to raise_error('api_key should be set')
+        expect { ::Nexmos::Base.new('', 'test_secret') }.to raise_error('api_key should be set')
       end
       it 'should raise on empty api_secret' do
-        expect {::Nexmos::Base.new('test_key', '')}.to raise_error('api_secret should be set')
+        expect { ::Nexmos::Base.new('test_key', '') }.to raise_error('api_secret should be set')
       end
       it 'should set default_params with values from ::Nexmos module' do
         ::Nexmos.setup do |c|
-          c.api_key = 'default_key'
+          c.api_key    = 'default_key'
           c.api_secret = 'default_secret'
         end
         instance = ::Nexmos::Base.new
-        instance.instance_variable_get('@default_params').should == {'api_key' => 'default_key', 'api_secret' => 'default_secret'}
+        expect(instance.instance_variable_get('@default_params')).to eq({ 'api_key' => 'default_key', 'api_secret' => 'default_secret' })
       end
       it 'should set default_params with custom api key and secret' do
         instance = ::Nexmos::Base.new('test_key', 'test_secret')
-        instance.instance_variable_get('@default_params').should == {'api_key' => 'test_key', 'api_secret' => 'test_secret'}
+        expect(instance.instance_variable_get('@default_params')).to eq({ 'api_key' => 'test_key', 'api_secret' => 'test_secret' })
       end
     end
 
-    its(:connection) { should be_kind_of(::Faraday::Connection) }
+    describe '#connection' do
+      subject { super().connection }
+      it { is_expected.to be_kind_of(::Faraday::Connection) }
+    end
 
     context 'make_api_call' do
 
       before(:each) do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret").
-                 with(:headers => {'Accept'=>'application/json', 'Accept-Encoding'=>'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent'=> ::Nexmos.user_agent}).
-                 to_return(:status => 200, :body => {'key' => 'value'}, :headers => {})
+          with(:headers => { 'Accept' => 'application/json', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent' => ::Nexmos.user_agent }).
+          to_return(:status => 200, :body => { 'key' => 'value' }.to_json, :headers => { 'Content-Type' => 'application/json' })
       end
 
       let(:api_params_without_required) do
         {
           :method => :get,
-          :url => '/test/url'
+          :url    => '/test/url'
         }
       end
 
       let(:api_params_with_required) do
         {
-          :method => :get,
-          :url => '/test/url',
+          :method   => :get,
+          :url      => '/test/url',
           :required => %w(key1 key2)
         }
       end
 
       it 'should call check_required_params' do
-        subject.should_receive(:check_required_params)
+        expect(subject).to receive(:check_required_params)
         subject.make_api_call(api_params_with_required)
       end
 
       it 'should raise if all required params missing' do
-        expect{subject.make_api_call(api_params_with_required)}.to raise_error('key1,key2 params required')
+        expect { subject.make_api_call(api_params_with_required) }.to raise_error('key1,key2 params required')
       end
 
       it 'should raise if some required params missing' do
-        expect{subject.make_api_call(api_params_with_required,{:key1 => 'val'})}.to raise_error('key2 params required')
+        expect { subject.make_api_call(api_params_with_required, { :key1 => 'val' }) }.to raise_error('key2 params required')
       end
 
       it 'should call normalize_params' do
-        subject.should_receive(:normalize_params).and_call_original
+        expect(subject).to receive(:normalize_params).and_call_original
         subject.make_api_call(api_params_without_required)
       end
 
       it 'should not call camelize_params' do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret&test_call=value").
-                 with(webmock_default_headers).
-                 to_return(:status => 200, :body => {}, :headers => {})
-        subject.should_not_receive(:camelize_params)
-        subject.make_api_call(api_params_without_required, {'test_call' => 'value'})
+          with(webmock_default_headers).
+          to_return(:status => 200, :body => {}.to_json, :headers => { 'Content-Type' => 'application/json' })
+        expect(subject).not_to receive(:camelize_params)
+        subject.make_api_call(api_params_without_required, { 'test_call' => 'value' })
       end
 
       it 'should call camelize_params' do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret&testCall=value").
-                 with(webmock_default_headers).
-                 to_return(:status => 200, :body => {}, :headers => {})
-        subject.should_receive(:camelize_params).and_call_original
-        subject.make_api_call(api_params_without_required.merge(:camelize => true), {'test_call' => 'value'})
+          with(webmock_default_headers).
+          to_return(:status => 200, :body => {}.to_json, :headers => { 'Content-Type' => 'application/json' })
+        expect(subject).to receive(:camelize_params).and_call_original
+        subject.make_api_call(api_params_without_required.merge(:camelize => true), { 'test_call' => 'value' })
       end
 
       it 'should call get_response' do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret").
-                 with(webmock_default_headers).
-                 to_return(:status => 200, :body => {}, :headers => {})
-        subject.should_receive(:get_response).and_call_original
+          with(webmock_default_headers).
+          to_return(:status => 200, :body => {}.to_json, :headers => { 'Content-Type' => 'application/json' })
+        expect(subject).to receive(:get_response).and_call_original
         subject.make_api_call(api_params_without_required)
       end
 
       it 'should return hash' do
-        subject.make_api_call(api_params_without_required).should be_a_kind_of(::Hash)
+        expect(subject.make_api_call(api_params_without_required)).to be_a_kind_of(::Hash)
       end
 
       it 'should return Hashie::Mash' do
-        subject.make_api_call(api_params_without_required).should be_a_kind_of(::Hashie::Mash)
+        expect(subject.make_api_call(api_params_without_required)).to be_a_kind_of(::Hashie::Mash)
       end
 
       it 'should respond to success? method in result' do
-        subject.make_api_call(api_params_without_required).should respond_to(:success?)
+        expect(subject.make_api_call(api_params_without_required)).to respond_to(:success?)
       end
 
       it 'should have success? key in hash' do
-        subject.make_api_call(api_params_without_required)[:success?].should be
+        expect(subject.make_api_call(api_params_without_required)[:success?]).to be
       end
 
       it 'should have success? == true' do
-        subject.make_api_call(api_params_without_required)[:success?].should be_true
+        expect(subject.make_api_call(api_params_without_required)[:success?]).to be_truthy
       end
 
       it 'should have success? == false on response with status != 200' do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret&testCall=value").
-                 with(webmock_default_headers).
-                 to_return(:status => 410, :body => {}, :headers => {})
-        res = subject.make_api_call(api_params_without_required.merge(:camelize => true), {'test_call' => 'value'})
-        res[:success?].should be_false
-        res[:failed?].should be_false
-        res[:not_authorized?].should be_false
+          with(webmock_default_headers).
+          to_return(:status => 410, :body => {}.to_json, :headers => { 'Content-Type' => 'application/json' })
+        res = subject.make_api_call(api_params_without_required.merge(:camelize => true), { 'test_call' => 'value' })
+        expect(res[:success?]).to be_falsey
+        expect(res[:failed?]).to be_falsey
+        expect(res[:not_authorized?]).to be_falsey
       end
 
       it 'should have not_authorized? == true' do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret&testCall=value").
-                 with(webmock_default_headers).
-                 to_return(:status => 401, :body => {}, :headers => {})
-        res = subject.make_api_call(api_params_without_required.merge(:camelize => true), {'test_call' => 'value'})
-        res[:success?].should be_false
-        res[:not_authorized?].should be_true
-        res[:failed?].should be_false
+          with(webmock_default_headers).
+          to_return(:status => 401, :body => {}.to_json, :headers => { 'Content-Type' => 'application/json' })
+        res = subject.make_api_call(api_params_without_required.merge(:camelize => true), { 'test_call' => 'value' })
+        expect(res[:success?]).to be_falsey
+        expect(res[:not_authorized?]).to be_truthy
+        expect(res[:failed?]).to be_falsey
       end
 
       it 'should have failed? == true' do
         stub_request(:get, "https://rest.nexmo.com/test/url?api_key=test_api&api_secret=test_secret&testCall=value").
-                 with(webmock_default_headers).
-                 to_return(:status => 420, :body => {}, :headers => {})
-        res = subject.make_api_call(api_params_without_required.merge(:camelize => true), {'test_call' => 'value'})
-        res[:success?].should be_false
-        res[:not_authorized?].should be_false
-        res[:failed?].should be_true
+          with(webmock_default_headers).
+          to_return(:status => 420, :body => {}.to_json, :headers => { 'Content-Type' => 'application/json' })
+        res = subject.make_api_call(api_params_without_required.merge(:camelize => true), { 'test_call' => 'value' })
+        expect(res[:success?]).to be_falsey
+        expect(res[:not_authorized?]).to be_falsey
+        expect(res[:failed?]).to be_truthy
       end
 
     end