addressfinder 1.10.0 → 1.10.1

data/spec/lib/addressfinder/bulk_spec.rb

@@ -1,207 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe AddressFinder::Bulk do
-  before do
-    AddressFinder.configure do |af|
-      af.api_key = 'XXX'
-      af.api_secret = 'YYY'
-      af.default_country = 'nz'
-      af.timeout = 5
-      af.retries = 5
-    end
-  end
-
-  describe '#perform' do
-    let(:http){ AddressFinder::HTTP.new(AddressFinder.configuration) }
-    let(:net_http){ http.send(:net_http) }
-
-    before do
-      WebMock.allow_net_connect!(net_http_connect_on_start: true)
-      allow(http).to receive(:sleep)
-    end
-
-    after do
-      WebMock.disable_net_connect!
-    end
-
-    context "with 3 requests in the provided block" do
-      let(:response){ double(:response, body: %Q({"success": true}), code: "200") }
-      let(:block){
-        Proc.new do |proxy|
-          proxy.verification(q: "1 Willis")
-          proxy.verification(q: "2 Willis")
-          proxy.verification(q: "3 Willis")
-        end
-      }
-
-      it "uses 1 http connection" do
-        expect(net_http).to receive(:do_start).once.and_call_original
-        expect(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        expect(net_http).to receive(:do_finish).once.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v2', default_country: 'au', &block).perform
-      end
-
-      it "calls the correct class with v2 verification and au default" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::V2::Au::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v2', default_country: 'au', &block).perform
-      end
-
-      it "calls the correct class with v2 verification and nz default" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v2', default_country: 'nz', &block).perform
-      end
-
-      it "calls the correct class without a verification version" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: nil, default_country: 'au', &block).perform
-      end
-
-      it "re-establishes the http connection and continues where we left off when a Net::OpenTimeout, Net::ReadTimeout or SocketError is raised" do
-        expect(http).to receive(:re_establish_connection).exactly(3).times.and_call_original
-        expect(net_http).to receive(:do_start).exactly(4).times.and_call_original
-        expect(net_http).to receive(:transport_request).once.and_return(response) # 1 Willis (success)
-        expect(net_http).to receive(:transport_request).once.and_raise(Net::OpenTimeout) # 2 Willis (error)
-        expect(net_http).to receive(:transport_request).once.and_raise(Net::ReadTimeout) # Retry 2 Willis (error)
-        expect(net_http).to receive(:transport_request).once.and_raise(SocketError) # Retry 2 Willis (error)
-        expect(net_http).to receive(:transport_request).exactly(2).and_return(response) # Retry 2 Willis (success) & 3 Willis (success)
-        expect(net_http).to receive(:do_finish).exactly(4).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v2', default_country: 'au', &block).perform
-      end
-    end
-
-    context "with the deprecated cleanse method" do
-      let(:response){ double(:response, body: %Q({"success": true}), code: "200") }
-      let(:block){
-        Proc.new do |proxy|
-          proxy.cleanse(q: "1 Willis")
-        end
-      }
-
-      it "has the same behaviour as the verification method" do
-        expect(net_http).to receive(:do_start).once.and_call_original
-        expect(net_http).to receive(:transport_request).once.and_return(response)
-        expect(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::Verification).to receive(:new).exactly(1).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: nil, default_country: 'au', &block).perform
-      end
-    end
-
-    context "with a country override and v2 in the config" do
-      let(:response){ double(:response, body: %Q({"success": true}), code: "200") }
-      let(:block){
-        Proc.new do |proxy|
-          proxy.verification(q: "1 Willis", country: "au")
-        end
-      }
-
-      it "has the same behaviour as the verification method" do
-        expect(net_http).to receive(:do_start).once.and_call_original
-        expect(net_http).to receive(:transport_request).once.and_return(response)
-        expect(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::V2::Au::Verification).to receive(:new).exactly(1).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: "v2", default_country: 'nz', &block).perform
-      end
-    end
-
-    context "email verification with 3 requests in the provided block" do
-      let(:response){ double(:response, body: %Q({"success": true}), code: "200") }
-      let(:block){
-        Proc.new do |proxy|
-          proxy.email_verification(email: "john.doe@addressfinder.com")
-          proxy.email_verification(email: "jane.doe@addressfinder.com")
-          proxy.email_verification(email: "tom.doe@addressfinder.com")
-        end
-      }
-
-      it "uses 1 http connection" do
-        expect(net_http).to receive(:do_start).once.and_call_original
-        expect(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        expect(net_http).to receive(:do_finish).once.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v1', default_country: 'nz', &block).perform
-      end
-
-      it "calls the correct class with v1 verification and nz default" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::V1::Email::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v1', default_country: 'nz', &block).perform
-      end
-
-      it "calls the correct class without a verification version or default country" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::V1::Email::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: nil, default_country: nil, &block).perform
-      end
-
-      it "re-establishes the http connection and continues where we left off when a Net::OpenTimeout, Net::ReadTimeout or SocketError is raised" do
-        expect(http).to receive(:re_establish_connection).exactly(3).times.and_call_original
-        expect(net_http).to receive(:do_start).exactly(4).times.and_call_original
-        expect(net_http).to receive(:transport_request).once.and_return(response) # john.doe@addressfinder.com (success)
-        expect(net_http).to receive(:transport_request).once.and_raise(Net::OpenTimeout) # jane.doe@addressfinder.com (error)
-        expect(net_http).to receive(:transport_request).once.and_raise(Net::ReadTimeout) # Retry jane.doe@addressfinder.com (error)
-        expect(net_http).to receive(:transport_request).once.and_raise(SocketError) # Retry jane.doe@addressfinder.com (error)
-        expect(net_http).to receive(:transport_request).exactly(2).and_return(response) # Retry jane.doe@addressfinder.com (success) & tom.doe@addressfinder.com (success)
-        expect(net_http).to receive(:do_finish).exactly(4).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v1', default_country: 'nz', &block).perform
-      end
-    end
-
-    context "phone verification with 3 requests in the provided block" do
-      let(:response){ double(:response, body: %Q({"success": true}), code: "200") }
-      let(:block){
-        Proc.new do |proxy|
-          proxy.phone_verification(phone_number: "+64274673830", default_country_code: "AU")
-          proxy.phone_verification(phone_number: "1800 152 363", default_country_code: "AU")
-          proxy.phone_verification(phone_number: "0274673830", default_country_code: "NZ")
-        end
-      }
-
-      it "uses 1 http connection" do
-        expect(net_http).to receive(:do_start).once.and_call_original
-        expect(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        expect(net_http).to receive(:do_finish).once.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v1', default_country: 'nz', &block).perform
-      end
-
-      it "calls the correct class with v1 verification and nz default" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::V1::Phone::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v1', default_country: 'nz', &block).perform
-      end
-
-      it "calls the correct class without a verification version or default country" do
-        allow(net_http).to receive(:do_start).once.and_call_original
-        allow(net_http).to receive(:transport_request).exactly(3).times.and_return(response)
-        allow(net_http).to receive(:do_finish).once.and_call_original
-        expect(AddressFinder::V1::Phone::Verification).to receive(:new).exactly(3).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: nil, default_country: nil, &block).perform
-      end
-
-      it "re-establishes the http connection and continues where we left off when a Net::OpenTimeout, Net::ReadTimeout or SocketError is raised" do
-        expect(http).to receive(:re_establish_connection).exactly(3).times.and_call_original
-        expect(net_http).to receive(:do_start).exactly(4).times.and_call_original
-        expect(net_http).to receive(:transport_request).once.and_return(response) # +64274673830 (success)
-        expect(net_http).to receive(:transport_request).once.and_raise(Net::OpenTimeout) # 1800 152 363 (error)
-        expect(net_http).to receive(:transport_request).once.and_raise(Net::ReadTimeout) # Retry 1800 152 363 (error)
-        expect(net_http).to receive(:transport_request).once.and_raise(SocketError) # Retry 1800 152 363 (error)
-        expect(net_http).to receive(:transport_request).exactly(2).and_return(response) # Retry 1800 152 363 (success) & 0274673830 (success)
-        expect(net_http).to receive(:do_finish).exactly(4).times.and_call_original
-        AddressFinder::Bulk.new(http: http, verification_version: 'v1', default_country: 'nz', &block).perform
-      end
-    end
-  end
-end

data/spec/lib/addressfinder/location_info_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe AddressFinder::LocationInfo do
-  before do
-    AddressFinder.configure do |af|
-      af.api_key = 'XXX'
-      af.api_secret = 'YYY'
-      af.default_country = 'au'
-    end
-  end
-
-  describe '#build_request' do
-    let(:locator){ AddressFinder::LocationInfo.new(params: args, http: http) }
-    let(:http){ AddressFinder::HTTP.new(AddressFinder.configuration) }
-
-    subject(:request_uri){ locator.send(:build_request) }
-
-    context 'with a simple PXID' do
-      let(:args){ {pxid: '123'} }
-
-      it { expect(request_uri).to eq('/api/au/location/info.json?pxid=123&key=XXX&secret=YYY') }
-    end
-
-    context 'with a country override' do
-      let(:args){ {pxid: '123', country: 'nz'} }
-
-      it { expect(request_uri).to eq('/api/nz/location/info.json?pxid=123&key=XXX&secret=YYY') }
-    end
-
-    context 'with a key override' do
-      let(:args){ {pxid: '123', key: 'AAA'} }
-
-      it { expect(request_uri).to eq('/api/au/location/info.json?pxid=123&key=AAA&secret=YYY') }
-    end
-
-    context 'with a secret override' do
-      let(:args){ {pxid: '123', secret: 'BBB'} }
-
-      it { expect(request_uri).to eq('/api/au/location/info.json?pxid=123&secret=BBB&key=XXX') }
-    end
-
-    context 'with a domain given' do
-      let(:args){ {pxid: '123', domain: 'testdomain.com'} }
-
-      it { expect(request_uri).to eq('/api/au/location/info.json?pxid=123&domain=testdomain.com&key=XXX&secret=YYY') }
-
-      context 'given in the AF configuration' do
-
-        let(:args){ {pxid: '123'} }
-
-        it 'should use the config domain if set' do
-          AddressFinder.configuration.domain = 'anotherdomain.com'
-          expect(request_uri).to eq('/api/au/location/info.json?pxid=123&domain=anotherdomain.com&key=XXX&secret=YYY')
-          AddressFinder.configuration.domain = nil # set back to nil after
-        end
-      end
-    end
-  end
-
-  describe '#build_result' do
-    let(:locator){ AddressFinder::LocationInfo.new(params: {q: 'ignored'}, http: nil) }
-
-    before do
-      locator.send('response_body=', body)
-      locator.send('response_status=', status)
-    end
-
-    subject(:result){ locator.send(:build_result) }
-
-    context 'with a successful result' do
-      let(:body){ '{"a":"Seaview Road, Glenfield, Auckland","city":"Auckland","suburb":"Glenfield","region":"Auckland Region","x":174.713938691835,"y":-36.7894885545157,"pxid":"1-.1.6.j.1F","street":"Seaview Road"}' }
-      let(:status){ '200' }
-
-      it { expect(result.class).to eq(AddressFinder::LocationInfo::Result) }
-      it { expect(result.a).to eq("Seaview Road, Glenfield, Auckland") }
-      it { expect(result.pxid).to eq("1-.1.6.j.1F") }
-    end
-  end
-end

data/spec/lib/addressfinder/location_search_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe AddressFinder::LocationSearch do
-  before do
-    AddressFinder.configure do |af|
-      af.api_key = 'XXX'
-      af.api_secret = 'YYY'
-      af.default_country = 'nz'
-    end
-  end
-
-  describe '#build_request' do
-    let(:locator){ AddressFinder::LocationSearch.new(params: args, http: http) }
-    let(:http){ AddressFinder::HTTP.new(AddressFinder.configuration) }
-
-    subject(:request_uri){ locator.send(:build_request) }
-
-    context 'with minimal arguments' do
-      let(:args){ {q: 'willis'} }
-
-      it { expect(request_uri).to eq('/api/nz/location.json?q=willis&key=XXX&secret=YYY') }
-    end
-
-    context 'with more arguments' do
-      let(:args){ {q: 'willis st', street: 1, max: 10} }
-
-      it { expect(request_uri).to eq('/api/nz/location.json?q=willis+st&street=1&max=10&key=XXX&secret=YYY') }
-    end
-
-    context 'with a country override' do
-      let(:args){ {q: 'willis st', country: 'au'} }
-
-      it { expect(request_uri).to eq('/api/au/location.json?q=willis+st&key=XXX&secret=YYY') }
-    end
-
-    context 'with a key override' do
-      let(:args){ {q: 'willis st', key: 'AAA'} }
-
-      it { expect(request_uri).to eq('/api/nz/location.json?q=willis+st&key=AAA&secret=YYY') }
-    end
-
-    context 'with a secret override' do
-      let(:args){ {q: 'willis st', secret: 'BBB'} }
-
-      it { expect(request_uri).to eq('/api/nz/location.json?q=willis+st&secret=BBB&key=XXX') }
-    end
-
-    context 'with a domain given' do
-      let(:args){ {q: '123', domain: 'testdomain.com'} }
-
-      it { expect(request_uri).to eq('/api/nz/location.json?q=123&domain=testdomain.com&key=XXX&secret=YYY') }
-
-      context 'given in the AF configuration' do
-
-        let(:args){ {q: '123'} }
-
-        it 'should use the config domain if set' do
-          AddressFinder.configuration.domain = 'anotherdomain.com'
-          expect(request_uri).to eq('/api/nz/location.json?q=123&domain=anotherdomain.com&key=XXX&secret=YYY')
-          AddressFinder.configuration.domain = nil # set back to nil after
-        end
-      end
-    end
-  end
-
-  describe '#build_result' do
-    let(:locator){ AddressFinder::LocationSearch.new(params: {q: 'ignored'}, http: nil) }
-
-    before do
-      locator.send('response_body=', body)
-      locator.send('response_status=', status)
-      locator.send(:build_result)
-    end
-
-    subject(:results){ locator.results }
-
-    context 'with completions' do
-      let(:body){ '{"completions":[{"a":"Willowbank","pxid":"1-.B.3l","v":0},{"a":"Willowby","pxid":"1-.3.4O","v":0}],"paid":true}' }
-      let(:status){ '200' }
-
-      it { expect(results.size).to eq(2) }
-      it { expect(results.first.class).to eq(AddressFinder::LocationSearch::Result) }
-      it { expect(results.first.a).to eq("Willowbank") }
-    end
-
-    context 'with no completions' do
-      let(:body){ '{"completions":[],"paid":true}' }
-      let(:status){ '200' }
-
-      it { expect(results).to eq([]) }
-    end
-  end
-end

data/spec/lib/addressfinder/util_spec.rb

@@ -1,37 +0,0 @@
-require 'addressfinder/util'
-
-RSpec.describe AddressFinder::Util do
-  describe '.encode_and_join_params' do
-    subject { AddressFinder::Util.encode_and_join_params(params) }
-
-    context 'with a question mark value' do
-      let(:params){ {q:'?',format:'json',key:'XXX',secret:'YYY'} }
-
-      it { is_expected.to eq('q=%3F&format=json&key=XXX&secret=YYY') }
-    end
-
-    context 'with an ampersand value' do
-      let(:params){ {q:'&',format:'json',key:'XXX',secret:'YYY'} }
-
-      it { is_expected.to eq('q=%26&format=json&key=XXX&secret=YYY') }
-    end
-
-    context 'with a normal address value' do
-      let(:params){ {q:'12 high',format:'json',key:'XXX',secret:'YYY'} }
-
-      it { is_expected.to eq('q=12+high&format=json&key=XXX&secret=YYY') }
-    end
-
-    context 'with a blank value' do
-      let(:params){ {q:'',format:'json',key:'XXX',secret:'YYY'} }
-
-      it { is_expected.to eq('q=&format=json&key=XXX&secret=YYY') }
-    end
-
-    context 'with a nil value' do
-      let(:params){ {q:nil,format:'json',key:'XXX',secret:'YYY'} }
-
-      it { is_expected.to eq('q=&format=json&key=XXX&secret=YYY') }
-    end
-  end
-end

data/spec/lib/addressfinder/v1/email/verification_spec.rb

@@ -1,148 +0,0 @@
-require "spec_helper"
-
-RSpec.describe AddressFinder::V1::Email::Verification do
-  before do
-    AddressFinder.configure do |af|
-      af.api_key = "XXX"
-      af.api_secret = "YYY"
-      af.timeout = 5
-      af.retries = 3
-    end
-  end
-
-  let(:verification_module){ AddressFinder::V1::Email::Verification.new(**args) }
-  let(:http){ AddressFinder::HTTP.new(AddressFinder.configuration) }
-  let(:net_http){ http.send(:net_http) }
-
-  describe "#execute_request" do
-    let(:args){ {email: "john.doe@addressfinder.com", http: http} }
-
-    before do
-      WebMock.allow_net_connect!(net_http_connect_on_start: true)
-      allow(http).to receive(:sleep)
-      allow(verification_module).to receive(:request_uri).and_return("/test/path")
-      expect(http).to_not receive(:re_establish_connection)
-    end
-
-    after do
-      WebMock.disable_net_connect!
-    end
-
-    subject(:execute_request){ verification_module.send(:execute_request) }
-
-    it "retries an errored request another time before succeeding" do
-      expect(net_http).to receive(:do_start).twice.and_call_original
-      expect(net_http).to receive(:transport_request).once.and_raise(Net::OpenTimeout)
-      expect(net_http).to receive(:transport_request).once.and_return(double(:response, body: "OK", code: "200"))
-      expect(net_http).to receive(:do_finish).twice.and_call_original
-      execute_request
-    end
-
-    it "re-raises a Net::OpenTimeout error after 3 retries" do
-      expect(net_http).to receive(:do_start).exactly(4).times.and_call_original
-      expect(net_http).to receive(:transport_request).exactly(4).times.and_raise(Net::OpenTimeout)
-      expect(net_http).to receive(:do_finish).exactly(4).times.and_call_original
-      expect{execute_request}.to raise_error(Net::OpenTimeout)
-    end
-
-    it "re-raises a Net::ReadTimeout error after 3 retries" do
-      expect(net_http).to receive(:do_start).exactly(4).times.and_call_original
-      expect(net_http).to receive(:transport_request).exactly(4).times.and_raise(Net::ReadTimeout)
-      expect(net_http).to receive(:do_finish).exactly(4).times.and_call_original
-      expect{execute_request}.to raise_error(Net::ReadTimeout)
-    end
-
-    it "re-raises a SocketError error after 3 retries" do
-      expect(net_http).to receive(:do_start).exactly(4).times.and_call_original
-      expect(net_http).to receive(:transport_request).exactly(4).times.and_raise(SocketError)
-      expect(net_http).to receive(:do_finish).exactly(4).times.and_call_original
-      expect{execute_request}.to raise_error(SocketError)
-    end
-  end
-
-  describe "#build_request" do
-    subject(:request_uri){ verification_module.send(:build_request) }
-
-    context "with email argument" do
-      let(:args){ {email: "john.doe@addressfinder.com", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&key=XXX&secret=YYY&format=json") }
-    end
-
-    context "with email and format arguments" do
-      let(:args){ {email: "john.doe@addressfinder.com", format: "xml", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&format=xml&key=XXX&secret=YYY") }
-    end
-
-    context "with a reserved character in the email" do
-      let(:args){ {email: "john=doe@addressfinder.com", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john%3Ddoe%40addressfinder.com&key=XXX&secret=YYY&format=json") }
-    end
-
-    context "with a key override" do
-      let(:args){ {email: "john.doe@addressfinder.com", key: "AAA", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&key=AAA&secret=YYY&format=json") }
-    end
-
-    context "with a secret override" do
-      let(:args){ {email: "john.doe@addressfinder.com", secret: "BBB", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&secret=BBB&key=XXX&format=json") }
-    end
-
-    context "with a domain given" do
-      let(:args){ {email: "john.doe@addressfinder.com", domain: "testdomain.com", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&domain=testdomain.com&key=XXX&secret=YYY&format=json") }
-
-      context "given in the AF configuration" do
-        let(:args){ {email: "john.doe@addressfinder.com", http: http} }
-
-        it "should use the config domain if set" do
-          AddressFinder.configuration.domain = "anotherdomain.com"
-          expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&domain=anotherdomain.com&key=XXX&secret=YYY&format=json")
-          AddressFinder.configuration.domain = nil # set back to nil after
-        end
-      end
-    end
-
-    context "with a all arguments included in request" do
-      let(:args){ {email: "john.doe@addressfinder.com", domain: "mysite.com", key: "AAA", secret: "BBB", format: "json", http: http} }
-
-      it { expect(request_uri).to eq("/api/email/v1/verification?email=john.doe%40addressfinder.com&domain=mysite.com&key=AAA&secret=BBB&format=json") }
-    end
-  end
-
-  describe "#build_result" do
-    let(:args){ {email: "ignored", http: nil} }
-
-    before do
-      verification_module.send("response_body=", body)
-      verification_module.send("response_status=", status)
-    end
-
-    subject(:result){ verification_module.send(:build_result) }
-
-    context "with a successful verification" do
-      let(:body){ '{"email_account": "john.doe", "email_domain": "addressfinder.com", "is_verified": true, "success": true}' }
-      let(:status){ "200" }
-
-      it { expect(result.class).to eq(AddressFinder::V1::Email::Verification::Result) }
-      it { expect(result.is_verified).to eq(true) }
-      it { expect(result.email_account).to eq("john.doe") }
-    end
-
-    context "with an unsuccessful verification" do
-      let(:body){ '{"email_account": "jane.doe", "email_domain": "addressfinder.com", "is_verified": false, "not_verified_reason": "The email account does not exist", "success": true}' }
-      let(:status){ "200" }
-
-      it { expect(result.class).to eq(AddressFinder::V1::Email::Verification::Result) }
-      it { expect(result.is_verified).to eq(false) }
-      it { expect(result.email_account).to eq("jane.doe") }
-      it { expect(result.not_verified_reason).to eq("The email account does not exist") }
-    end
-  end
-end