verifalia 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc088dd144b948e544784c59efe27b5ccb8fe225
-  data.tar.gz: 1164f7c900fce6f4d16eddad18c9fefe3f87b345
+  metadata.gz: 13ecdf0dda8a8b5eed02d2fbc681f57f46905e4e
+  data.tar.gz: 45a067871869dacd52fce6649d6ecf6f244a71e8
 SHA512:
-  metadata.gz: 1c2b30d6e970065d07f88be34ad8a393c16aea08497054dcbd8ed21f3e9183b03fc4b89f1950ed033eaee4562db3aa36a9cfe7c3f58cd0a3ff7c93150676ec0a
-  data.tar.gz: 91e06b91158db5bff1465e86d318603a7c39278611cfe009c5e916f21fa7f8d7cb84e9549445dd1126b10a61da1f8de0c1961361b6654cd18e33411b956307e1
+  metadata.gz: fc7beb23842a872e087cfc3e44af72cef66e67fbc4f36a303610fe39185cc13afbc0bad27370fb65fdb5abaf3e274b18d4b2c7364615f2c33c0f6b5fdd32d633
+  data.tar.gz: 7676bc471f56549a75b4e7303341500c69b86f091567b0edfa7f7a6dcca4ab0443e5aba2ac5273c3a6c2bd60ab72d5433ddc2ece045aa5e8ea50cf3b2ba1a6bf

data/.gitignore

@@ -20,4 +20,5 @@ tmp
 *.o
 *.a
 mkmf.log
-.rvmrc
+.rvmrc
+test.rb

data/README.md

@@ -92,12 +92,15 @@ options = { #view verifalia API documentation
 if (unique_id = @client.email_validations.verify(emails, options))
   #response is an hash with all the values returned
   response = @client.email_validations.query
-  @client.email_validations.destroy
+  @client.email_validations.destroy #destroy the job on the Verifalia server
 else
   #error is HTTP status code in symbol (:bad_request)
   error = @client.email_validations.error
 end
 
+#you can wait for job completion using options on query
+response = @client.email_validations.query(wait_for_completion: true, completion_max_retry: 2, completion_interval: 1)
+
 
 ##with previous unique id
 unique_id = "example-example"
@@ -113,4 +116,6 @@ if @client.email_validations(unique_id: unique_id).completed?
   response = @client.email_validations(unique_id: unique_id).query
 end
 
+#checking account_balance. Remember to enable this feature in Verifalia dashboard or you get a :forbidden error
+@client.account_balance.balance
 ```

data/lib/rest/account_balance.rb

@@ -0,0 +1,93 @@
+require 'rest_client'
+require 'json'
+module Verifalia
+  module REST
+    class AccountBalance
+      ##
+      # The Verifalia::REST::AccountBalance class allow you to comminucate
+      # with Account balance Api. You don't need to instantiate this class, but
+      # use the client for autoconfiguration. # The +args+ parameter is a hash of configuration
+      def initialize(config, account_sid, account_token, args = {})
+        @resources = build_resources(config, account_sid, account_token)
+      end
+
+      ##
+      # Query the Account balance
+      #
+      def balance()
+        begin
+          response = multiplex_request do |resource|
+            resource[@unique_id].get
+          end
+          @error = nil
+          JSON.parse(response)
+        rescue => e
+          compute_error(e)
+          false
+        end
+      end
+
+      def error
+        @error
+      end
+
+      private
+
+        def multiplex_request
+          @resources.shuffle.each do |resource|
+            begin
+              response = yield(resource)
+              return response
+            rescue => e
+              if ((e.is_a? RestClient::Exception) && (e.http_code != 500))
+                raise e
+              end
+            end
+          end
+          raise RestClient::Exception.new(nil, 500)
+        end
+
+        def compute_error(e)
+          unless e.is_a? RestClient::Exception
+            @error = :internal_server_error
+          end
+
+          case e.http_code
+            when 400
+              @error = :bad_request
+            when 401
+              @error = :unauthorized
+            when 402
+              @error = :payment_required
+            when 403
+              @error = :forbidden
+            when 404
+              @error = :not_found
+            when 406
+              @error = :not_acceptable
+            when 410
+              @error = :gone
+            when 429
+              @error = :too_many_request
+            else
+              @error = :internal_server_error
+            end
+        end
+
+        def build_resources(config, account_sid, account_token)
+          opts = {
+            user: account_sid,
+            password: account_token,
+            headers: {
+              content_type: :json,
+              user_agent: "verifalia-rest-client/ruby/#{Verifalia::VERSION}"
+            }
+          }
+          config[:hosts].map do |host|
+            api_url = "#{host}/#{config[:api_version]}/account-balance"
+            RestClient::Resource.new api_url, opts
+          end
+        end
+    end
+  end
+end

data/lib/rest/client.rb

@@ -1,4 +1,5 @@
 require 'rest/email_validations'
+require 'rest/account_balance'
 
 module Verifalia
   module REST
@@ -25,7 +26,7 @@ module Verifalia
       API_VERSION = 'v1.4'
 
       DEFAULTS = {
-        host: 'https://api.verifalia.com',
+        hosts: ['https://api-1.verifalia.com', 'https://api-2.verifalia.com'],
         api_version: 'v1.4'
       }
 
@@ -70,6 +71,13 @@ module Verifalia
         end
       end
 
+      ##
+      # Instantiate a new HTTP client to talk to Verifalia Account Balance Api.
+      #
+      def account_balance()
+        @account_balance ||= AccountBalance.new @config, @account_sid, @auth_token
+      end
+
     end
   end
 end

data/lib/rest/email_validations.rb

@@ -3,6 +3,9 @@ require 'json'
 module Verifalia
   module REST
     class EmailValidations
+
+      COMPLETION_MAX_RETRY = 5
+      COMPLETION_INTERVAL = 1
       ##
       # The Verifalia::REST::EmailValidations class allow you to comminucate
       # with Email Validations Api. You don't need to instantiate this class, but
@@ -14,14 +17,16 @@ module Verifalia
       # The unique if of the Verifalia Email Validation resource
       #
       def initialize(config, account_sid, account_token, args = {})
-        @resource = build_resource(config, account_sid, account_token)
+        @resources = build_resources(config, account_sid, account_token)
         @unique_id = args[:unique_id] if args[:unique_id]
       end
 
       ##
       # Query the Email Validations Api with:
       #
-      # === <tt> emails: ['test@test.com']
+      # === <tt> inputs: ['test@test.com']
+      # === <tt> inputs: data = [{ inputData: 'first@first.it' }, { inputData: 'first@first.it' } ]
+      # === <tt> options: { quality: 'high', priority: 100, deduplication: 'safe' } view verifalia API documentation
       #
       # An array of emails to validate
       #
@@ -40,11 +45,12 @@ module Verifalia
         end
         content = ({ entries: data }.merge(options)).to_json
         begin
-          r = @resource.post content
-          @unique_id = JSON.parse(r)["uniqueID"]
-          @response = nil
+          @response = multiplex_request do |resource|
+            resource.post content
+          end
+          @query_result = JSON.parse(@response)
+          @unique_id = @query_result["uniqueID"]
           @error = nil
-          @query_result = nil
           @unique_id
         rescue => e
           compute_error(e)
@@ -57,19 +63,39 @@ module Verifalia
       # this method you need to supply unique_id uring initialization or call verify first. If request fail,
       # you can call <tt>error</tt> to receive detailed information
       #
-      def query
+      # === <tt> options: { wait_for_completion: true, completion_max_retry: 5, completion_interval: 1(seconds) }
+      def query(options = {})
         raise ArgumentError, 'You must call verify first or supply and uniqueId' unless @unique_id
-        if @response == nil || @response.code != 200
+        opts = {
+          wait_for_completion: false,
+          completion_max_retry: COMPLETION_MAX_RETRY,
+          completion_interval: COMPLETION_INTERVAL,
+          }
+          .merge! options
+        if @query_result == nil || !completed?
           begin
-            @response = @resource[@unique_id].get
-            @query_result = JSON.parse(@response)
-            @error = nil
+            loop_count = 0
+            loop do
+              @response = multiplex_request do |resource|
+                resource[@unique_id].get
+              end
+              @query_result = JSON.parse(@response)
+              @error = nil
+              loop_count += 1
+              sleep opts[:completion_interval] if opts[:wait_for_completion]
+              break if !opts[:wait_for_completion] || (completed? || loop_count >= opts[:completion_max_retry])
+            end
           rescue => e
             compute_error(e)
             return false
           end
         end
-        @query_result
+        if (opts[:wait_for_completion] && !completed?)
+          @error = :not_completed
+          false
+        else
+          @query_result
+        end
       end
 
       ##
@@ -80,13 +106,16 @@ module Verifalia
       def destroy
         raise ArgumentError, 'You must call verify first or supply and uniqueId' unless @unique_id
         begin
-          r = @resource[@unique_id].delete
+          r = multiplex_request do |resource|
+            resource[@unique_id].delete
+          end
           @error = nil
           @response = nil
           @query_result = nil
           @unique_id = nil
           true
         rescue => e
+          return true if (e.is_a? RestClient::Exception && e.http_code == 410)
           compute_error(e)
           return false
         end
@@ -97,8 +126,7 @@ module Verifalia
       # this method you need to supply unique_id during initialization or call verify first.
       #
       def completed?
-        query_progress = query["progress"]
-        @response.code == 200 && query_progress["noOfTotalEntries"] == query_progress["noOfCompletedEntries"]
+        @response.code == 200
       end
 
       def error
@@ -106,6 +134,21 @@ module Verifalia
       end
 
       private
+
+        def multiplex_request
+          @resources.shuffle.each do |resource|
+            begin
+              response = yield(resource)
+              return response
+            rescue => e
+              if ((e.is_a? RestClient::Exception) && (e.http_code != 500))
+                raise e
+              end
+            end
+          end
+          raise RestClient::Exception.new(nil, 500)
+        end
+
         def compute_error(e)
           unless e.is_a? RestClient::Exception
             @error = :internal_server_error
@@ -118,25 +161,34 @@ module Verifalia
               @error = :unauthorized
             when 402
               @error = :payment_required
+            when 403
+              @error = :forbidden
             when 404
               @error = :not_found
             when 406
               @error = :not_acceptable
             when 410
               @error = :gone
+            when 429
+              @error = :too_many_request
             else
               @error = :internal_server_error
             end
         end
 
-        def build_resource(config, account_sid, account_token)
-          api_url = "#{config[:host]}/#{config[:api_version]}/email-validations"
+        def build_resources(config, account_sid, account_token)
           opts = {
             user: account_sid,
             password: account_token,
-            headers: { content_type: :json }
+            headers: {
+              content_type: :json,
+              user_agent: "verifalia-rest-client/ruby/#{Verifalia::VERSION}"
+            }
           }
-          return RestClient::Resource.new api_url, opts
+          config[:hosts].map do |host|
+            api_url = "#{host}/#{config[:api_version]}/email-validations"
+            RestClient::Resource.new api_url, opts
+          end
         end
     end
   end

data/lib/verifalia/util/configuration.rb

@@ -1,7 +1,7 @@
 module Verifalia
   module Util
     class Configuration
-      attr_accessor :account_sid, :auth_token
+      attr_accessor :account_sid, :auth_token, :hosts
     end
   end
-end
+end

data/lib/verifalia/version.rb

@@ -1,3 +1,3 @@
 module Verifalia
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/spec/rest/account_balance_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Verifalia::REST::AccountBalance do
+  let(:config) { { hosts: ["https://api.fake.com", "https://api-2.fake.com"], api_version: "v" } }
+
+  describe '#initialize' do
+
+    it 'create RestClient::Resource with correct parameters' do
+      opts = {
+        user: 'someSid',
+        password: 'someToken',
+        headers: { content_type: :json, user_agent: "verifalia-rest-client/ruby/#{Verifalia::VERSION}" }
+      }
+      config[:hosts].each do |host|
+        api_url = "#{host}/#{config[:api_version]}/account-balance"
+        expect(RestClient::Resource).to receive(:new).with(api_url, opts)
+      end
+      Verifalia::REST::AccountBalance.new(config, 'someSid', 'someToken')
+    end
+
+    it 'associate RestClient::Resource to @resources' do
+      resource = double()
+      allow(RestClient::Resource).to receive(:new).and_return(resource)
+      account_balance = Verifalia::REST::AccountBalance.new(config, 'someSid', 'someToken')
+      expect(account_balance.instance_variable_get('@resources')).to include(resource)
+      expect(account_balance.instance_variable_get('@resources').size).to eq(config[:hosts].size)
+    end
+  end
+
+  context 'initialized' do
+    let(:resources) { [ double().as_null_object, double().as_null_object ] }
+    let(:response) { double().as_null_object }
+    let(:response_json) { double().as_null_object }
+
+    before(:each) do
+      @account_balance = Verifalia::REST::AccountBalance.new(config, 'someSid', 'someToken')
+      @account_balance.instance_variable_set('@resources', resources)
+    end
+
+    describe '#balance' do
+
+      context 'without errors' do
+        it 'call #get on @resources' do
+          resources.each { |resource| allow(resource).to receive(:get).and_return(response) }
+          expect(JSON).to receive(:parse).with(response).and_return(response_json)
+          @account_balance.balance
+        end
+
+        it 'return parsed json' do
+          parsed = double()
+          resources.each { |resource| allow(resource).to receive(:get).and_return(response) }
+          expect(JSON).to receive(:parse).and_return(parsed)
+          result = @account_balance.balance
+          expect(result).to eq(parsed)
+        end
+      end
+
+      context 'request failed' do
+
+        before(:each) do
+          resources.each { |resource| allow(resource).to receive(:get).and_raise(RestClient::Exception.new(nil, 402))}
+        end
+
+        it 'raise exception, call #compute_error and return false' do
+          result = @account_balance.balance
+          expect(result).to eq(false)
+        end
+
+        it 'raise exception, call #compute_error and return correct error' do
+          result = @account_balance.balance
+          expect(result).to eq(false)
+          expect(@account_balance.error).to eq(:payment_required)
+        end
+      end
+
+      context 'with one request failed with 500' do
+        before(:each) do
+          expect(resources).to receive(:shuffle).and_return([resources[0], resources[1]])
+          expect(resources[0]).to receive(:get).and_raise(RestClient::Exception.new(nil, 500))
+          expect(resources[1]).to receive(:get).and_return(response)
+        end
+
+        it 'return parsed json' do
+          parsed = double()
+          expect(JSON).to receive(:parse).and_return(parsed)
+          result = @account_balance.balance
+          expect(result).to eq(parsed)
+        end
+      end
+    end
+  end
+
+end

data/spec/rest/client_spec.rb

@@ -45,10 +45,10 @@ describe Verifalia::REST::Client do
         config.auth_token = 'someToken'
       end
 
-      client = Verifalia::REST::Client.new :host => 'api.fake.com'
+      client = Verifalia::REST::Client.new :hosts => ['api.fake.com']
 
       config = client.instance_variable_get('@config')
-      expect(config[:host]).to eq('api.fake.com')
+      expect(config[:hosts]).to eq(['api.fake.com'])
     end
 
     it 'should throw an argument error if the sid and token isn\'t set' do
@@ -59,7 +59,7 @@ describe Verifalia::REST::Client do
       expect { Verifalia::REST::Client.new 'someSid' }.to raise_error(ArgumentError)
     end
   end
-  
+
   describe '#email_validations' do
     before(:each) do
       Verifalia.configure do |config|
@@ -68,7 +68,7 @@ describe Verifalia::REST::Client do
       end
       @client = Verifalia::REST::Client.new
     end
-    
+
     context 'without parameters' do
       it 'call #new on Verifalia::REST::EmailValidations with correct paramenters' do
         config = @client.instance_variable_get('@config')
@@ -76,7 +76,7 @@ describe Verifalia::REST::Client do
         @client.email_validations
       end
     end
-    
+
     context 'with parameter' do
       it 'call #new on Verifalia::REST::EmailValidations with correct paramenters' do
         config = @client.instance_variable_get('@config')
@@ -85,4 +85,21 @@ describe Verifalia::REST::Client do
       end
     end
   end
-end
+
+
+  describe '#account_balance' do
+    before(:each) do
+      Verifalia.configure do |config|
+        config.account_sid = 'someSid'
+        config.auth_token = 'someToken'
+      end
+      @client = Verifalia::REST::Client.new
+    end
+
+    it 'call #new on Verifalia::REST::AccountBalance with correct paramenters' do
+      config = @client.instance_variable_get('@config')
+      expect(Verifalia::REST::AccountBalance).to receive(:new).with(config, 'someSid', 'someToken')
+      @client.account_balance
+    end
+  end
+end

data/spec/rest/email_validations_spec.rb

@@ -1,27 +1,29 @@
 require 'spec_helper'
 
 describe Verifalia::REST::EmailValidations do
-  let(:config) { { host: 'https://api.fake.com', api_version: "v" } }
+  let(:config) { { hosts: ["https://api.fake.com", "https://api-2.fake.com"], api_version: "v" } }
 
   describe '#initialize' do
 
     it 'create RestClient::Resource with correct parameters' do
-      api_url = "#{config[:host]}/#{config[:api_version]}/email-validations"
       opts = {
         user: 'someSid',
         password: 'someToken',
-        headers: { content_type: :json }
+        headers: { content_type: :json, user_agent: "verifalia-rest-client/ruby/#{Verifalia::VERSION}" }
       }
-
-      expect(RestClient::Resource).to receive(:new).with(api_url, opts)
+      config[:hosts].each do |host|
+        api_url = "#{host}/#{config[:api_version]}/email-validations"
+        expect(RestClient::Resource).to receive(:new).with(api_url, opts)
+      end
       Verifalia::REST::EmailValidations.new(config, 'someSid', 'someToken')
     end
 
-    it 'associate RestClient::Resource to @resource' do
+    it 'associate RestClient::Resource to @resources' do
       resource = double()
       allow(RestClient::Resource).to receive(:new).and_return(resource)
       email_validations = Verifalia::REST::EmailValidations.new(config, 'someSid', 'someToken')
-      expect(email_validations.instance_variable_get('@resource')).to eq(resource)
+      expect(email_validations.instance_variable_get('@resources')).to include(resource)
+      expect(email_validations.instance_variable_get('@resources').size).to eq(config[:hosts].size)
     end
 
     it 'associate :unique_id to @unique_id' do
@@ -33,12 +35,12 @@ describe Verifalia::REST::EmailValidations do
   end
 
   context 'initialized' do
-    let(:resource) { double().as_null_object }
+    let(:resources) { [ double().as_null_object, double().as_null_object ] }
     let(:response) { double().as_null_object }
     let(:response_json) { double().as_null_object }
     before(:each) do
       @email_validations = Verifalia::REST::EmailValidations.new(config, 'someSid', 'someToken')
-      @email_validations.instance_variable_set('@resource', resource)
+      @email_validations.instance_variable_set('@resources', resources)
     end
 
     describe '#verify' do
@@ -69,81 +71,99 @@ describe Verifalia::REST::EmailValidations do
         expect{ @email_validations.verify(inputs) }.to raise_error(ArgumentError)
       end
 
-      it 'call #post on @resources with string array parameters' do
-        emails = ['first', 'second']
-        data = emails.map { |email| { inputData: email }}
-        content = { entries: data }.to_json
-        expect(resource).to receive(:post).with(content).and_return(response)
-        expect(JSON).to receive(:parse).with(response).and_return(response_json)
-        @email_validations.verify(emails)
-      end
+      context 'without errors' do
 
-      it 'call #post on @resources with string array parameters and options' do
-        emails = ['first', 'second']
-        options = { option_1: 'test' }
-        data = emails.map { |email| { inputData: email }}
-        content = { entries: data, option_1: 'test' }.to_json
-        expect(resource).to receive(:post).with(content).and_return(response)
-        expect(JSON).to receive(:parse).with(response).and_return(response_json)
-        @email_validations.verify(emails, options)
-      end
+        it 'call #post on resource with string array parameters' do
+          emails = ['first', 'second']
+          data = emails.map { |email| { inputData: email }}
+          content = { entries: data }.to_json
+          resources.each { |resource| allow(resource).to receive(:post).with(content).and_return(response) }
+          expect(JSON).to receive(:parse).with(response).and_return(response_json)
+          @email_validations.verify(emails)
+        end
 
-      it 'call #post on @resources with hash array parameters with valid value' do
-        data = [
-          {
-            inputData: 'first'
-          },
-          {
-            inputData: 'second'
-          }
-        ]
-        content = { entries: data }.to_json
-        expect(resource).to receive(:post).with(content).and_return(response)
-        expect(JSON).to receive(:parse).with(response).and_return(response_json)
-        @email_validations.verify(data)
-      end
+        it 'call #post on resource with string array parameters and options' do
+          emails = ['first', 'second']
+          options = { option_1: 'test' }
+          data = emails.map { |email| { inputData: email }}
+          content = { entries: data, option_1: 'test' }.to_json
+          resources.each { |resource| allow(resource).to receive(:post).with(content).and_return(response) }
+          expect(JSON).to receive(:parse).with(response).and_return(response_json)
+          @email_validations.verify(emails, options)
+        end
 
-      it 'associate @unique_id and clear @response and @error' do
-        emails = ['first', 'second']
-        unique_id = 'fake'
-        parsed = double()
-        expect(JSON).to receive(:parse).and_return(parsed)
-        expect(parsed).to receive(:[]).with("uniqueID").and_return(unique_id)
-        @email_validations.verify(emails)
-        expect(@email_validations.instance_variable_get('@unique_id')).to eq(unique_id)
-        expect(@email_validations.instance_variable_get('@response')).to eq(nil)
-        expect(@email_validations.instance_variable_get('@error')).to eq(nil)
-      end
+        it 'call #post on @resources with hash array parameters with valid value' do
+          data = [
+            {
+              inputData: 'first'
+            },
+            {
+              inputData: 'second'
+            }
+          ]
+          content = { entries: data }.to_json
+          resources.each { |resource| allow(resource).to receive(:post).with(content).and_return(response) }
+          expect(JSON).to receive(:parse).with(response).and_return(response_json)
+          @email_validations.verify(data)
+        end
 
-      it 'return @unique_id' do
-        emails = ['first', 'second']
-        unique_id = 'fake'
-        parsed = double()
-        expect(JSON).to receive(:parse).and_return(parsed)
-        expect(parsed).to receive(:[]).with("uniqueID").and_return(unique_id)
-        result = @email_validations.verify(emails)
-        expect(result).to eq(unique_id)
+        it 'associate @unique_id' do
+          emails = ['first', 'second']
+          unique_id = 'fake'
+          parsed = double()
+          expect(JSON).to receive(:parse).and_return(parsed)
+          expect(parsed).to receive(:[]).with("uniqueID").and_return(unique_id)
+          @email_validations.verify(emails)
+          expect(@email_validations.instance_variable_get('@unique_id')).to eq(unique_id)
+        end
+
+        it 'return @unique_id' do
+          emails = ['first', 'second']
+          unique_id = 'fake'
+          parsed = double()
+          expect(JSON).to receive(:parse).and_return(parsed)
+          expect(parsed).to receive(:[]).with("uniqueID").and_return(unique_id)
+          result = @email_validations.verify(emails)
+          expect(result).to eq(unique_id)
+        end
       end
 
-      context 'request failed' do
+      context 'requests failed' do
+
+        before(:each) do
+          resources.each { |resource| allow(resource).to receive(:post).and_raise(RestClient::Exception.new(nil, 402))}
+        end
 
         it 'raise exception, call #compute_error and return false' do
           emails = ['first', 'second']
-          expect(resource).to receive(:post).and_raise(RestClient::Exception)
           result = @email_validations.verify(emails)
           expect(result).to eq(false)
-          expect(@email_validations.error).to eq(:internal_server_error)
         end
 
         it 'raise exception, call #compute_error and return correct error' do
           emails = ['first', 'second']
-          exception = RestClient::Exception.new(nil, 402)
-          expect(resource).to receive(:post).and_raise(exception)
           result = @email_validations.verify(emails)
           expect(result).to eq(false)
           expect(@email_validations.error).to eq(:payment_required)
         end
       end
+
+      context 'with one request failed with 500' do
+        before(:each) do
+          expect(resources).to receive(:shuffle).and_return([resources[0], resources[1]])
+          expect(resources[0]).to receive(:post).and_raise(RestClient::Exception.new(nil, 500))
+          expect(resources[1]).to receive(:post).and_return(response)
+        end
+
+        it 'should return @unique_id' do
+          emails = ['first', 'second']
+          unique_id = 'fake'
+          expect(JSON).to receive(:parse).with(response).and_return(response_json)
+          expect(response_json).to receive(:[]).with("uniqueID").and_return(unique_id)
+          result = @email_validations.verify(emails)
+          expect(result).to eq(unique_id)
+        end
+      end
     end
 
     describe '#query' do
@@ -156,34 +176,114 @@ describe Verifalia::REST::EmailValidations do
           @email_validations.instance_variable_set('@unique_id', 'fake')
         end
 
-        it 'call #get on @resource[@uniqueId] with correct parameters' do
-          request = double()
-          expect(resource).to receive(:[]).with('fake').and_return(request)
-          expect(request).to receive(:get).and_return(double().as_null_object)
-          expect(JSON).to receive(:parse)
-          @email_validations.query
-        end
+        context 'without errors' do
+          it 'call #get on @resource[@uniqueId] with correct parameters' do
+            request = double()
+            resources.each do |resource|
+              allow(resource).to receive(:[]).with('fake').and_return(request)
+              allow(request).to receive(:get).and_return(double().as_null_object)
+            end
+            expect(JSON).to receive(:parse)
+            @email_validations.query
+          end
 
-        it 'return parsed json' do
-          parsed = double()
-          expect(resource).to receive(:[]).with('fake')
-          expect(JSON).to receive(:parse).and_return(parsed)
-          result = @email_validations.query
-          expect(result).to eq(parsed)
+          it 'should return parsed json' do
+            request = double()
+            parsed = double()
+            resources.each do |resource|
+              allow(resource).to receive(:[]).with('fake').and_return(request)
+              allow(request).to receive(:get).and_return(double().as_null_object)
+            end
+            expect(JSON).to receive(:parse).and_return(parsed)
+            result = @email_validations.query
+            expect(result).to eq(parsed)
+          end
+
+          context 'with completion' do
+            it 'call #get on @resource[@uniqueId] multiple time' do
+              request = double()
+              resources.each do |resource|
+                allow(resource).to receive(:[]).with('fake').and_return(request)
+                allow(request).to receive(:get).and_return(double().as_null_object)
+              end
+              allow(JSON).to receive(:parse)
+              @email_validations.query(wait_for_completion: true, completion_max_retry: 2)
+            end
+          end
         end
 
         context 'request failed' do
 
-          it 'raise exception, call #compute_error and return false' do
+          before(:each) do
             request = double()
-            expect(resource).to receive(:[]).with('fake').and_return(request)
-            expect(request).to receive(:get).and_raise(RestClient::Exception)
+            resources.each do |resource|
+
+            end
+          end
+
+          it 'raise exception, call #compute_error and return false' do
             expect(@email_validations).to receive(:compute_error).and_return(double())
             result = @email_validations.query
             expect(result).to eq(false)
           end
         end
 
+        context 'with one request failed with 500' do
+          before(:each) do
+            request_1 = double()
+            request_2 = double()
+            response = double()
+            expect(resources).to receive(:shuffle).and_return([resources[0], resources[1]])
+            expect(resources[0]).to receive(:[]).with('fake').and_return(request_1)
+            expect(request_1).to receive(:get).and_raise(RestClient::Exception.new(nil, 500))
+            expect(resources[1]).to receive(:[]).with('fake').and_return(request_2)
+            allow(request_2).to receive(:get).and_return(double().as_null_object)
+          end
+
+          it 'should return parsed json' do
+            parsed = double()
+            expect(JSON).to receive(:parse).and_return(parsed)
+            result = @email_validations.query
+            expect(result).to eq(parsed)
+          end
+        end
+      end
+    end
+
+    describe '#destroy' do
+      it 'raise ArgumentError without @unique_id' do
+        expect{ @email_validations.destroy }.to raise_error(ArgumentError)
+      end
+
+      context 'with @unique_id' do
+        before(:each) do
+          @email_validations.instance_variable_set('@unique_id', 'fake')
+        end
+
+        context 'without errors' do
+
+          it 'call #delete on @resource[@uniqueId]' do
+            request = double()
+            resources.each do |resource|
+              allow(resource).to receive(:[]).with('fake').and_return(request)
+              allow(request).to receive(:delete).and_return(double().as_null_object)
+            end
+            @email_validations.destroy
+          end
+
+          it 'clear @response, @unique_id and @error' do
+            request = double()
+            resources.each do |resource|
+              allow(resource).to receive(:[]).with('fake').and_return(request)
+              allow(request).to receive(:delete).and_return(double().as_null_object)
+            end
+            @email_validations.destroy
+            expect(@email_validations.instance_variable_get('@response')).to eq(nil)
+            expect(@email_validations.instance_variable_get('@unique_id')).to eq(nil)
+            expect(@email_validations.instance_variable_get('@error')).to eq(nil)
+          end
+
+        end
       end
     end
 
@@ -198,7 +298,6 @@ describe Verifalia::REST::EmailValidations do
       context 'with 202 http code response' do
         before(:each) do
           allow(response).to receive(:code).and_return(202)
-          allow(@email_validations).to receive(:query).and_return({ "progress" => nil })
         end
 
         it 'should return false' do
@@ -207,57 +306,17 @@ describe Verifalia::REST::EmailValidations do
       end
 
       context 'with 200 http code response' do
-        let(:completed_query) do
-          { "progress"=> { "noOfTotalEntries" => 1, "noOfCompletedEntries" => 1 } }
-        end
-        let(:incompleted_query) do
-          { "progress"=> { "noOfTotalEntries" => 0, "noOfCompletedEntries" => 1 } }
-        end
 
         before(:each) do
           allow(response).to receive(:code).and_return(200)
         end
 
-        it 'should return true if completed' do
-          allow(@email_validations).to receive(:query).and_return(completed_query)
+        it 'should return true' do
           expect(@email_validations.completed?).to be true
         end
-
-        it 'should return false if not completed' do
-          allow(@email_validations).to receive(:query).and_return(incompleted_query)
-          expect(@email_validations.completed?).to be false
-        end
       end
     end
 
-    describe '#destroy' do
-      it 'raise ArgumentError without @unique_id' do
-        expect{ @email_validations.destroy }.to raise_error(ArgumentError)
-      end
-
-      context 'with @unique_id' do
-        before(:each) do
-          @email_validations.instance_variable_set('@unique_id', 'fake')
-        end
-
-        it 'call #delete on @resource[@uniqueId]' do
-          request = double()
-          expect(resource).to receive(:[]).with('fake').and_return(request)
-          expect(request).to receive(:delete).and_return(double().as_null_object)
-          @email_validations.destroy
-        end
-
-        it 'clear @response, @unique_id and @error' do
-          request = double()
-          expect(resource).to receive(:[]).with('fake').and_return(request)
-          expect(request).to receive(:delete).and_return(double().as_null_object)
-          @email_validations.destroy
-          expect(@email_validations.instance_variable_get('@response')).to eq(nil)
-          expect(@email_validations.instance_variable_get('@unique_id')).to eq(nil)
-          expect(@email_validations.instance_variable_get('@error')).to eq(nil)
-        end
-      end
-    end
   end
 
 end

data/verifalia.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.rdoc_options = ['--line-numbers', '--inline-source', '--title', '--main', 'README.md']
 
   spec.add_dependency('builder', '>= 2.1.2')
-  spec.add_dependency('rest-client', '> 1.8.0')
+  spec.add_dependency('rest-client', '>= 2.0.0')
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: verifalia
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Verifalia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-22 00:00:00.000000000 Z
+date: 2017-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -28,16 +28,16 @@ dependencies:
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,11 +80,13 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/rest/account_balance.rb
 - lib/rest/client.rb
 - lib/rest/email_validations.rb
 - lib/verifalia.rb
 - lib/verifalia/util/configuration.rb
 - lib/verifalia/version.rb
+- spec/rest/account_balance_spec.rb
 - spec/rest/client_spec.rb
 - spec/rest/email_validations_spec.rb
 - spec/spec_helper.rb
@@ -121,6 +123,7 @@ signing_key:
 specification_version: 4
 summary: Verifalia API wrapper (email validation, list cleaning and scrubbing)
 test_files:
+- spec/rest/account_balance_spec.rb
 - spec/rest/client_spec.rb
 - spec/rest/email_validations_spec.rb
 - spec/spec_helper.rb