postcode_anywhere-email_validation 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzQzODgyZDZhM2Y1ZDkwZmVmMjMxZDBiMzM3ZjEyMDY3MzNmMjUwMQ==
+  data.tar.gz: !binary |-
+    YWE0MGMxMjliOWQzMTg4OTU1Mzc2MWRkYjc2NTc1ZTYzYmQ3YTExYg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZWIxZGZmY2M0ZTlhMDYwNWNlZjc0MzBmMDg2ZjMxYjgyMTc0ZGJkNWFkMzlj
+    ZjI5OWRiZDMyYTkxNjRiNTQ1ZmFmOTAyMjJhMjgyMGM2NmFmYzllOWUyYjcw
+    ZjdmNWIxMDJjYThlOWNjMTA3YWNiYTdhNzk1ZjJiMTc2NTUwMDk=
+  data.tar.gz: !binary |-
+    MjFiM2JjN2UxZDAwMzIwODI4NmFhMzM5ZTkxMDcyZjYzMGM1MWI4ODg2YzYz
+    MjI0YzNjM2VlMjUyYzIwMWM5ZTNlZmMzZDFkNGI1MzU2M2FiOWU3Y2VlNmRk
+    ZDU3M2FkZTMwNGM0ZGNiZWQyNzZlYmNiZTU5MzI0YjQ3NzM0MmY=

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+.config
+Gemfile.lock
+pkg
+.idea
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pry'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Money Advice Service
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# PostcodeAnywhere::EmailValidation
+
+Verifies the existence of an email address using the
+[Email Validation web services] [email-validation]
+from [PostcodeAnywhere].
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```sh
+gem 'postcode_anywhere-email_validation'
+```
+
+And then execute:
+
+```sh
+$ bundle
+```
+
+Or install it yourself as:
+
+```sh
+$ gem install postcode_anywhere-email_validation
+```
+
+## Usage
+
+```ruby
+PostcodeAnywhere::EmailValidation.key = 'AA11-AA11-AA11-AA11'
+PostcodeAnywhere::EmailValidation.valid?('info@google.com') #=> true
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[postcodeanywhere]: http://www.postcodeanywhere.co.uk/
+  "PostcodeAnywhere"
+
+[email-validation]: http://www.postcodeanywhere.co.uk/email-validation/
+  "PostcodeAnywhere's Email Validation web services"

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/postcode_anywhere/email_validation/response.rb

@@ -0,0 +1,51 @@
+require 'json'
+
+module PostcodeAnywhere
+  module EmailValidation
+    class Response
+
+      def self.parse(json)
+        response = JSON.parse(json)['Items'].first
+        error    = if response['Error']
+                     ValidationError.new(response['Description'],
+                                         code:       response['Error'],
+                                         cause:      response['Cause'],
+                                         resolution: response['Resolution'])
+                   end
+
+        new(response['ValidFormat'], response['FoundDnsRecord'], error)
+      end
+
+      def valid?
+        raise error if error?
+
+        valid_format? && valid_dns_record?
+      end
+
+      private
+
+      attr_accessor :valid_format
+      attr_accessor :found_dns_record
+      attr_accessor :error
+
+      def initialize(valid_format, found_dns_record, error)
+        self.valid_format     = valid_format
+        self.found_dns_record = found_dns_record
+        self.error            = error
+      end
+
+      def valid_format?
+        !!valid_format
+      end
+
+      def valid_dns_record?
+        !!found_dns_record
+      end
+
+      def error?
+        !!error
+      end
+
+    end
+  end
+end

data/lib/postcode_anywhere/email_validation/validation_error.rb

@@ -0,0 +1,17 @@
+module PostcodeAnywhere
+  module EmailValidation
+    class ValidationError < StandardError
+
+      attr_reader :code, :cause, :resolution
+
+      def initialize(message, metadata = {})
+        super(message)
+
+        @code       = metadata[:code]
+        @cause      = metadata[:cause]
+        @resolution = metadata[:resolution]
+      end
+
+    end
+  end
+end

data/lib/postcode_anywhere/email_validation/validator.rb

@@ -0,0 +1,13 @@
+require 'active_model'
+
+module PostcodeAnywhere
+  module EmailValidation
+    class Validator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        unless PostcodeAnywhere::EmailValidation.valid?(value)
+          record.errors.add(attribute, :invalid, value: value)
+        end
+      end
+    end
+  end
+end

data/lib/postcode_anywhere/email_validation/version.rb

@@ -0,0 +1,5 @@
+module PostcodeAnywhere
+  module EmailValidation
+    VERSION = '0.0.2'
+  end
+end

data/lib/postcode_anywhere/email_validation.rb

@@ -0,0 +1,26 @@
+require 'postcode_anywhere/email_validation/response'
+require 'postcode_anywhere/email_validation/validation_error'
+require 'postcode_anywhere/email_validation/validator'
+require 'postcode_anywhere/email_validation/version'
+
+require 'rest_client'
+
+module PostcodeAnywhere
+  module EmailValidation
+
+    HOST = 'http://services.postcodeanywhere.co.uk/' +
+        'EmailValidation/Interactive/Validate/v1.10/json3.ws'
+
+    class << self
+      attr_accessor :key
+
+      def valid?(email)
+        json     = RestClient.get(HOST, params: { Key: key, Email: email })
+        response = Response.parse(json)
+
+        response.valid?
+      end
+    end
+
+  end
+end

data/postcodeanywhere-emailvalidation.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'postcode_anywhere/email_validation/version'
+
+Gem::Specification.new do |spec|
+  spec.name                  = 'postcode_anywhere-email_validation'
+  spec.version               = PostcodeAnywhere::EmailValidation::VERSION
+  spec.authors               = ['Andrew Garner', 'Pablo Manrubia']
+  spec.email                 = ['andrew@surefirething.co.uk', 'pablo@advera.co.uk']
+  spec.description           = %q{Verify the existence of an email address.}
+  spec.summary               = %q{Verifies the existence of an email address using the Email Validation web services from PostcodeAnywhere.}
+  spec.homepage              = 'https://github.com/moneyadviceservice/postcode_anywhere-email_validation'
+  spec.date                  = "2013-06-04"
+  spec.files                 = `git ls-files`.split($/)
+  spec.executables           = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files            = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths         = ['lib']
+  spec.required_ruby_version = '>= 1.9.2'
+
+  spec.add_dependency 'rest-client', '~> 1.6'
+  spec.add_dependency 'activemodel', '~> 3.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'capybara', '~> 2.1'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.0'
+  spec.add_development_dependency 'vcr', '~> 2.4'
+  spec.add_development_dependency 'webmock', '~> 1.0'
+end

data/spec/features/email_validation_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+feature 'Validating an email address', :vcr do
+
+  background do
+    PostcodeAnywhere::EmailValidation.key = ENV['POSTCODE_ANYWHERE_KEY']
+  end
+
+  scenario 'With valid format and valid DNS record' do
+    expect(PostcodeAnywhere::EmailValidation.valid?('info@google.com')).to be_true
+  end
+
+  scenario 'With invalid format' do
+    expect(PostcodeAnywhere::EmailValidation.valid?('@google.com')).to be_false
+  end
+
+  scenario 'With invalid DNS record' do
+    expect(PostcodeAnywhere::EmailValidation.valid?('info@google.google')).to be_false
+  end
+
+  scenario 'Without API key' do
+    PostcodeAnywhere::EmailValidation.key = 'AA11-AA11-AA11-AA11'
+
+    expect { PostcodeAnywhere::EmailValidation.valid?('info@google.com') }.to raise_error(PostcodeAnywhere::EmailValidation::ValidationError)
+  end
+
+end

data/spec/features/email_validator_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+feature 'ActiveModel validator', :vcr do
+  background do
+    PostcodeAnywhere::EmailValidation.key = ENV['POSTCODE_ANYWHERE_KEY']
+  end
+
+  subject { ValidatedClass.new }
+
+  context 'with invalid values' do
+    %w(@example.com john.doe@).each do |value|
+      scenario "is not valid on value:  #{value.inspect}" do
+        subject.email = value
+        expect(subject).to_not be_valid
+      end
+    end
+
+  end
+
+  context 'with valid values' do
+    %w(pablo@google.com fake@jsf.io).each do |value|
+      scenario "is not valid on value:  #{value.inspect}" do
+        subject.email = value
+        expect(subject).to be_valid
+      end
+    end
+  end
+
+end

data/spec/lib/postcode_anywhere/email_validation/response_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module PostcodeAnywhere::EmailValidation
+  describe Response do
+    describe '.valid?' do
+      context 'when a DNS record is found and the format is valid' do
+        subject { described_class.new(true, true, nil) }
+
+        it { should be_valid }
+      end
+
+      context 'when a DNS record is not found' do
+        subject { described_class.new(true, false, nil) }
+
+        it { should_not be_valid }
+      end
+
+      context 'with invalid format' do
+        subject { described_class.new(false, true, nil) }
+
+        it { should_not be_valid }
+      end
+
+      describe 'with an error' do
+        let(:error) { ValidationError.new('An error',
+                                          code:       '999',
+                                          cause:      'A cause',
+                                          resolution: 'A resolution') }
+
+        subject { described_class.new(nil, nil, error) }
+
+        it 'raises a validation error' do
+          assertions = -> error {
+            expect(error).to be_instance_of(ValidationError)
+            expect(error.to_s).to eql('An error')
+            expect(error.code).to eql('999')
+            expect(error.cause).to eql('A cause')
+            expect(error.resolution).to eql('A resolution')
+          }
+
+          expect { subject.valid? }.to raise_error(&assertions)
+        end
+      end
+    end
+
+    describe '#parse' do
+      subject { described_class.parse(json) }
+
+      context 'with a successful response' do
+        let(:json) do
+          '
+            {
+              "Items": [
+                {
+                  "Email":"john.doe@example.com",
+                  "MailServer":"mail.example.com",
+                  "ValidFormat":true,
+                  "FoundDnsRecord":true
+                }
+              ]
+            }
+          '
+        end
+
+        it 'returns a response' do
+          described_class.should_receive(:new).with(true, true, nil).and_return :response
+
+          expect(subject).to eql(:response)
+        end
+      end
+
+      context 'with an error response' do
+        let(:json) do
+          '
+            {"Items":
+              [
+                {
+                  "Error":"999",
+                  "Description":"An error",
+                  "Cause":"A cause",
+                  "Resolution":"A resolution"
+                }
+              ]
+            }
+          '
+        end
+
+        it 'parses the error details' do
+          ValidationError.should_receive(:new).with('An error',
+                                                    code:       '999',
+                                                    cause:      'A cause',
+                                                    resolution: 'A resolution')
+
+          subject
+        end
+
+        it 'returns a response' do
+          described_class.should_receive(:new).with(nil, nil, an_instance_of(ValidationError)).and_return(:response)
+
+          expect(subject).to eql(:response)
+        end
+      end
+    end
+  end
+end

data/spec/lib/postcode_anywhere/email_validation/validation_error_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module PostcodeAnywhere::EmailValidation
+  describe ValidationError do
+    subject { described_class.new('An error') }
+
+    it { should be_kind_of(StandardError) }
+
+    it { should respond_to :message }
+    it { should respond_to :code }
+    it { should respond_to :cause }
+    it { should respond_to :resolution }
+
+    its(:to_s) { should eql('An error') }
+
+    context 'with metadata' do
+      subject do
+        described_class.new('An error',
+                            code:       '0',
+                            cause:      'A cause',
+                            resolution: 'A resolution')
+      end
+
+      its(:code) { should eql('0') }
+      its(:cause) { should eql('A cause') }
+      its(:resolution) { should eql('A resolution') }
+    end
+  end
+end

data/spec/lib/postcode_anywhere/email_validation/validator_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module PostcodeAnywhere
+  module EmailValidation
+
+    describe Validator do
+
+      subject { ::ValidatedClass.new }
+
+      context 'Using Postcode Anywhere' do
+        before { subject.email = 'an_email' }
+
+        it 'is valid if service returns true' do
+          PostcodeAnywhere::EmailValidation.should_receive(:valid?).with('an_email').and_return false
+          expect(subject).to_not be_valid
+        end
+
+        it 'is invalid if service returns false' do
+          PostcodeAnywhere::EmailValidation.should_receive(:valid?).with('an_email').and_return true
+          expect(subject).to be_valid
+        end
+      end
+
+    end
+  end
+end

data/spec/lib/postcode_anywhere/email_validation_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module PostcodeAnywhere
+  describe EmailValidation do
+    it { should respond_to(:key) }
+    it { should respond_to(:valid?).with(1).argument }
+
+    describe ".valid?" do
+      subject { described_class.valid?('john.doe@example.com') }
+
+      before(:all) do
+        described_class.key = :the_key
+      end
+
+      before(:each) do
+        stub_const('PostcodeAnywhere::EmailValidation::HOST', :host)
+
+        RestClient.
+            should_receive(:get).
+            with(:host, params: { Key: :the_key, Email: 'john.doe@example.com' }).
+            and_return(json)
+      end
+
+      context 'with a valid email and a DNS record is found' do
+        let(:json) { build_json }
+
+        it { should be_true }
+      end
+
+      context 'with invalid email' do
+        let(:json) { build_json(ValidFormat: false) }
+
+        it { should be_false }
+      end
+
+      context 'when a DNS entry is not found' do
+        let(:json) { build_json(FoundDnsRecord: false) }
+
+        it { should be_false }
+      end
+
+      context 'with an error' do
+        let(:json) do
+          %[
+            {"Items":
+              [
+                {
+                  "Error":"999",
+                  "Description":"An error",
+                  "Cause":"A cause",
+                  "Resolution":"A resolution"
+                }
+              ]
+            }
+          ]
+        end
+
+        it 'raises an exception when error' do
+          expect { subject }.to raise_error(EmailValidation::ValidationError)
+        end
+      end
+    end
+
+    def build_json(options = {})
+      default_options = { Email:          'john.doe@example.com',
+                          MailServer:     'mail.example.com',
+                          ValidFormat:    true,
+                          FoundDnsRecord: true }
+
+      { Items: [default_options.merge(options)] }.to_json
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+ENV['POSTCODE_ANYWHERE_KEY'] ||= 'AA11-AA11-AA11-AA11'
+
+require 'postcode_anywhere/email_validation'
+
+require 'capybara/rspec'
+require 'vcr'
+require 'pry'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.around(:each, :vcr) do |example|
+    name = example.metadata[:full_description].downcase.gsub(/[^\w\/]+/, '_')
+
+    VCR.use_cassette(name) { example.call }
+  end
+
+  config.order = 'random'
+end
+
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/support/fixtures/vcr_cassettes'
+  config.hook_into :webmock
+  config.filter_sensitive_data('{{Key}}') { ENV['POSTCODE_ANYWHERE_KEY'] }
+end

data/spec/support/fixtures/vcr_cassettes/activemodel_validator_with_invalid_values_is_not_valid_on_value_example_com_.yml

@@ -0,0 +1,71 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: http://services.postcodeanywhere.co.uk/EmailValidation/Interactive/Validate/v1.10/json3.ws?Email=@example.com&Key={{Key}}
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - ! '*/*; q=0.5, application/xml'
+      Accept-Encoding:
+      - gzip, deflate
+      User-Agent:
+      - Ruby
+  response:
+    status:
+      code: 200
+      message: !binary |-
+        T0s=
+    headers:
+      !binary "Q2FjaGUtQ29udHJvbA==":
+      - !binary |-
+        bm8tY2FjaGU=
+      !binary "UHJhZ21h":
+      - !binary |-
+        bm8tY2FjaGU=
+      !binary "Q29udGVudC1UeXBl":
+      - !binary |-
+        YXBwbGljYXRpb24vanNvbjtjaGFyc2V0PVVURi04
+      !binary "Q29udGVudC1FbmNvZGluZw==":
+      - !binary |-
+        Z3ppcA==
+      !binary "RXhwaXJlcw==":
+      - !binary |-
+        LTE=
+      !binary "U2VydmVy":
+      - !binary |-
+        TWljcm9zb2Z0LUlJUy83LjU=
+      !binary "QWNjZXNzLUNvbnRyb2wtQWxsb3ctT3JpZ2lu":
+      - !binary |-
+        Kg==
+      !binary "QWNjZXNzLUNvbnRyb2wtQWxsb3ctSGVhZGVycw==":
+      - !binary |-
+        Q29udGVudC1UeXBl
+      !binary "UmVjb3Jkcw==":
+      - !binary |-
+        MQ==
+      !binary "WC1Bc3BuZXQtVmVyc2lvbg==":
+      - !binary |-
+        NC4wLjMwMzE5
+      !binary "WC1Qb3dlcmVkLUJ5":
+      - !binary |-
+        QVNQLk5FVA==
+      !binary "RGF0ZQ==":
+      - !binary |-
+        VHVlLCAwNCBKdW4gMjAxMyAxNTowNjo0NyBHTVQ=
+      !binary "Q29udGVudC1MZW5ndGg=":
+      - !binary |-
+        MTk1
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        H4sIAAAAAAAEAOy9B2AcSZYlJi9tynt/SvVK1+B0oQiAYBMk2JBAEOzBiM3m
+        kuwdaUcjKasqgcplVmVdZhZAzO2dvPfee++999577733ujudTif33/8/XGZk
+        AWz2zkrayZ4hgKrIHz9+fB8/In7xR2dtvmg+evS9X/zR6SIryo8effTR6KMv
+        6LfXeX2Z1/L3T2ZlMXtW1Yus/ejReVY2+eijZ9V6OXu6bF7l06qe6ce/5Pu/
+        5P8JAAD//yqv5RRTAAAA
+    http_version: 
+  recorded_at: Tue, 04 Jun 2013 15:06:57 GMT
+recorded_with: VCR 2.5.0