verifalia 1.2.0 → 2.0.0

data/lib/rest/client.rb

@@ -1,83 +0,0 @@
-require 'rest/email_validations'
-require 'rest/account_balance'
-
-module Verifalia
-  module REST
-    ##
-    # The Verifalia::REST::Client class caches authentication parameters and
-    # exposes methods to make HTTP requests to Verifalia's REST API. However, you
-    # should never really need to call these methods yourself since you can
-    # work with the more pleasant wrapper objects like Verifalia::REST::EmailValidations
-    #
-    # Instantiate a client like so:
-    #
-    #   @client = Verifalia::REST::Client.new account_sid, auth_token
-    #
-
-    # Once you have a client object you can use it to do fun things. Every
-    # client object exposes a wrapper for a specific API. For example:
-    #
-    # ==== @client.email_validations
-    #
-    class Client
-
-      attr_reader :account_sid, :account_token
-
-      API_VERSION = 'v1.4'
-
-      DEFAULTS = {
-        hosts: ['https://api-1.verifalia.com', 'https://api-2.verifalia.com'],
-        api_version: 'v1.4'
-      }
-
-      ##
-      # Instantiate a new HTTP client to talk to Verifalia. The parameters
-      # +account_sid+ and +auth_token+ are required, unless you have configured
-      # them already using the block configure syntax, and used to generate the
-      # HTTP basic auth header in each request. The +args+ parameter is a
-      # hash of connection configuration options. the following keys are
-      # supported:
-      #
-      # === <tt>host: 'https://api.verifalia.com'</tt>
-      #
-      # === <tt>api_version: 'v1.1'</tt>
-      #
-      def initialize(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        @config = DEFAULTS.merge! options
-        @account_sid = args[0] || Verifalia.account_sid
-        @auth_token = args[1] || Verifalia.auth_token
-
-        if @account_sid.nil? || @auth_token.nil?
-          raise ArgumentError, 'Account SID and auth token are required'
-        end
-
-      end
-
-      ##
-      # Instantiate a new HTTP client to talk to Verifalia Email Validation Api.
-      # The +args+ parameter is a hash of configuration
-      # The following keys are supported:
-      #
-      # === <tt>unique_id: 'example-example'</tt>
-      #
-      # The unique if of the Verifalia Email Validation resource
-      #
-      def email_validations(args = {})
-        if (args.empty?)
-          @email_validations ||= EmailValidations.new @config, @account_sid, @auth_token
-        else
-          EmailValidations.new @config, @account_sid, @auth_token, args
-        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

@@ -1,195 +0,0 @@
-require 'rest_client'
-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
-      # use the client for autoconfiguration. # The +args+ parameter is a hash of configuration
-      # The following keys are supported:
-      #
-      # === <tt>unique_id: 'example-example'</tt>
-      #
-      # The unique if of the Verifalia Email Validation resource
-      #
-      def initialize(config, account_sid, account_token, args = {})
-        @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> 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
-      #
-      def verify(inputs, options = {})
-        raise ArgumentError, 'inputs must be not empty' if (inputs.nil? || inputs.empty?)
-        raise ArgumentError, 'options must be hash' if (!options.is_a?(Hash))
-        data = inputs.map do |input|
-          if (input.is_a? String)
-            { inputData: input }
-          elsif (input.is_a? Hash)
-            raise ArgumentError, 'if inputs content is a Hash you need to supply :inputData as key' if (!input.has_key?(:inputData))
-            input
-          else
-            raise ArgumentError, 'inputs content must be a String or a Hash'
-          end
-        end
-        content = ({ entries: data }.merge(options)).to_json
-        begin
-          @response = multiplex_request do |resource|
-            resource.post content
-          end
-          @query_result = JSON.parse(@response)
-          @unique_id = @query_result["uniqueID"]
-          @error = nil
-          @unique_id
-        rescue => e
-          compute_error(e)
-          false
-        end
-      end
-
-      ##
-      # Query the Email Validations Api for specific result. In order to use
-      # 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
-      #
-      # === <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
-        opts = {
-          wait_for_completion: false,
-          completion_max_retry: COMPLETION_MAX_RETRY,
-          completion_interval: COMPLETION_INTERVAL,
-          }
-          .merge! options
-        if @query_result == nil || !completed?
-          begin
-            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
-        if (opts[:wait_for_completion] && !completed?)
-          @error = :not_completed
-          false
-        else
-          @query_result
-        end
-      end
-
-      ##
-      # Destroy an Email Validations entity. In order to use
-      # this method you need to supply unique_id during initialization or call verify first. If request fail,
-      # you can call <tt>error</tt> to receive detailed information
-      #
-      def destroy
-        raise ArgumentError, 'You must call verify first or supply and uniqueId' unless @unique_id
-        begin
-          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
-      end
-
-      ##
-      # Check if the Email validation entity is completed processed. In order to use
-      # this method you need to supply unique_id during initialization or call verify first.
-      #
-      def completed?
-        @response.code == 200
-      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]}/email-validations"
-            RestClient::Resource.new api_url, opts
-          end
-        end
-    end
-  end
-end

data/lib/verifalia/util/configuration.rb

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

data/lib/verifalia/version.rb

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

data/spec/rest/account_balance_spec.rb

@@ -1,93 +0,0 @@
-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

@@ -1,105 +0,0 @@
-require 'spec_helper'
-
-describe Verifalia::REST::Client do
-  describe 'config at class level' do
-    after(:each) do
-      Verifalia.instance_variable_set('@configuration', nil)
-    end
-
-    it 'should set the account sid and auth token with a config block' do
-      Verifalia.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Verifalia::REST::Client.new
-      expect(client.account_sid).to eq('someSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
-    end
-
-    it 'should overwrite account sid and auth token if passed to initializer' do
-      Verifalia.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Verifalia::REST::Client.new 'otherSid', 'otherToken'
-      expect(client.account_sid).to eq('otherSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('otherToken')
-    end
-
-    it 'should overwrite the account sid if only the sid is given' do
-      Verifalia.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Verifalia::REST::Client.new 'otherSid'
-      expect(client.account_sid).to eq('otherSid')
-      expect(client.instance_variable_get('@auth_token')).to eq('someToken')
-    end
-
-    it 'should allow options after setting up auth with config' do
-      Verifalia.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      end
-
-      client = Verifalia::REST::Client.new :hosts => ['api.fake.com']
-
-      config = client.instance_variable_get('@config')
-      expect(config[:hosts]).to eq(['api.fake.com'])
-    end
-
-    it 'should throw an argument error if the sid and token isn\'t set' do
-      expect { Verifalia::REST::Client.new }.to raise_error(ArgumentError)
-    end
-
-    it 'should throw an argument error if only the account_sid is set' do
-      expect { Verifalia::REST::Client.new 'someSid' }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#email_validations' do
-    before(:each) do
-      Verifalia.configure do |config|
-        config.account_sid = 'someSid'
-        config.auth_token = 'someToken'
-      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')
-        expect(Verifalia::REST::EmailValidations).to receive(:new).with(config, 'someSid', 'someToken')
-        @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')
-        expect(Verifalia::REST::EmailValidations).to receive(:new).with(config, 'someSid', 'someToken', :unique_id => 'fake')
-        @client.email_validations(:unique_id => 'fake')
-      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