verifalia 1.1.0 → 2.0.0

data/lib/rest/email_validations.rb

@@ -1,143 +0,0 @@
-require 'rest_client'
-require 'json'
-module Verifalia
-  module REST
-    class EmailValidations
-      ##
-      # 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 = {})
-        @resource = build_resource(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']
-      #
-      # 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
-          r = @resource.post content
-          @unique_id = JSON.parse(r)["uniqueID"]
-          @response = nil
-          @error = nil
-          @query_result = 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
-      #
-      def query
-        raise ArgumentError, 'You must call verify first or supply and uniqueId' unless @unique_id
-        if @response == nil || @response.code != 200
-          begin
-            @response = @resource[@unique_id].get
-            @query_result = JSON.parse(@response)
-            @error = nil
-          rescue => e
-            compute_error(e)
-            return false
-          end
-        end
-        @query_result
-      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 = @resource[@unique_id].delete
-          @error = nil
-          @response = nil
-          @query_result = nil
-          @unique_id = nil
-          true
-        rescue => e
-          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?
-        query_progress = query["progress"]
-        @response.code == 200 && query_progress["noOfTotalEntries"] == query_progress["noOfCompletedEntries"]
-      end
-
-      def error
-        @error
-      end
-
-      private
-        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 404
-              @error = :not_found
-            when 406
-              @error = :not_acceptable
-            when 410
-              @error = :gone
-            else
-              @error = :internal_server_error
-            end
-        end
-
-        def build_resource(config, account_sid, account_token)
-          api_url = "#{config[:host]}/#{config[:api_version]}/email-validations"
-          opts = {
-            user: account_sid,
-            password: account_token,
-            headers: { content_type: :json }
-          }
-          return RestClient::Resource.new api_url, opts
-        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
-    end
-  end
-end

data/lib/verifalia/version.rb

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

data/spec/rest/client_spec.rb

@@ -1,88 +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 :host => 'api.fake.com'
-
-      config = client.instance_variable_get('@config')
-      expect(config[:host]).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
-end

data/spec/rest/email_validations_spec.rb

@@ -1,263 +0,0 @@
-require 'spec_helper'
-
-describe Verifalia::REST::EmailValidations do
-  let(:config) { { host: 'https://api.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 }
-      }
-
-      expect(RestClient::Resource).to receive(:new).with(api_url, opts)
-      Verifalia::REST::EmailValidations.new(config, 'someSid', 'someToken')
-    end
-
-    it 'associate RestClient::Resource to @resource' 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)
-    end
-
-    it 'associate :unique_id to @unique_id' do
-      unique_id = double()
-      email_validations = Verifalia::REST::EmailValidations.new(config, 'someSid', 'someToken', unique_id: unique_id)
-      expect(email_validations.instance_variable_get('@unique_id')).to eq(unique_id)
-    end
-
-  end
-
-  context 'initialized' do
-    let(:resource) { 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)
-    end
-
-    describe '#verify' do
-
-      it 'raise ArgumentError with nil emails' do
-        expect{ @email_validations.verify(nil) }.to raise_error(ArgumentError)
-      end
-
-      it 'raise ArgumentError with empty emails' do
-        expect{ @email_validations.verify([]) }.to raise_error(ArgumentError)
-      end
-
-      it 'raise ArgumentError with unvalid options' do
-        emails = ['first', 'second']
-        expect{ @email_validations.verify(emails, 'a string') }.to raise_error(ArgumentError)
-      end
-
-
-      it 'raise ArgumentError with with hash array parameters with invalid value' do
-        inputs = [
-          {
-            fakeKey: 'fake second'
-          },
-          {
-            fakeKey: 'fake second'
-          }
-        ]
-        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
-
-      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 @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 '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 '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
-
-      context 'request failed' do
-
-        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
-    end
-
-    describe '#query' do
-      it 'raise ArgumentError without @unique_id' do
-        expect{ @email_validations.query }.to raise_error(ArgumentError)
-      end
-
-      context 'with @unique_id' do
-        before(:each) 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
-
-        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)
-        end
-
-        context 'request failed' do
-
-          it 'raise exception, call #compute_error and return false' do
-            request = double()
-            expect(resource).to receive(:[]).with('fake').and_return(request)
-            expect(request).to receive(:get).and_raise(RestClient::Exception)
-            expect(@email_validations).to receive(:compute_error).and_return(double())
-            result = @email_validations.query
-            expect(result).to eq(false)
-          end
-        end
-
-      end
-    end
-
-    describe '#completed?' do
-      let(:response) { double().as_null_object }
-
-      before(:each) do
-        @email_validations.instance_variable_set('@response', response)
-      end
-
-
-      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
-          expect(@email_validations.completed?).to be false
-        end
-      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)
-          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/spec/spec_helper.rb

@@ -1,21 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'bundler'
-Bundler.setup
-
-require 'verifalia'
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end
-
-if ENV["CI"]
-  require 'coveralls'
-  Coveralls.wear!
-else
-  require "simplecov"
-  SimpleCov.start
-end
-

data/spec/util/configuration_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Verifalia::Util::Configuration do
-  it 'should have an account sid attribute' do
-    config = Verifalia::Util::Configuration.new
-    config.account_sid = 'someSid'
-    expect(config.account_sid).to eq('someSid')
-  end
-
-  it 'should have an auth token attribute' do
-    config = Verifalia::Util::Configuration.new
-    config.auth_token = 'someToken'
-    expect(config.auth_token).to eq('someToken')
-  end
-end

data/spec/verifalia_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Verifalia 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
-
-    expect(Verifalia.account_sid).to eq('someSid')
-    expect(Verifalia.auth_token).to eq('someToken')
-  end
-end