notifications-ruby-client 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cfd87a0ae55ca5a8d843a19bd9ffc99959ca646f
+  data.tar.gz: 48c8ed194a9364549035cdfe410103c22aa3988f
+SHA512:
+  metadata.gz: 048a94ca3bd1fe8d9c16fe91a24f8fe509e23119d4f4a86fd9fca38293cc5a829f5c40cef58d3c3630084984b7274f997cc416db0a0056e79d2a50f414493058
+  data.tar.gz: 04c883580688bd5a6e66ccb14d4abfb266e72f77880776c8ea1c435ae61e873c90b6228e2a9b0ec7b4e0a6f542a4e894156b31c4bba7b7d816928a2218155e3a

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+/vendor
+environment.sh
+/.idea/
+/.idea/vcs.xml

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+ - 2.2.2

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Government Digital Service
+
+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,159 @@
+# GOV.UK Notify Ruby client
+
+API client for GOV.UK Notify written in Ruby.
+
+[![Build Status](https://travis-ci.org/alphagov/notifications-ruby-client.svg?branch=master)](https://travis-ci.org/alphagov/notifications-ruby-client)
+
+## Installation
+
+Prior to usage an account must be created through the Notify admin console. This will allow access to the API credentials you application.
+
+You can then install the gem or require it in your application.
+
+```
+gem install 'notifications-ruby-client'
+```
+
+## Getting started
+
+```ruby
+require 'notifications-ruby-client'
+client = Notifications::Client.new(service_id, secret_id)
+```
+
+you can also override api endpoint
+
+```ruby
+client = Notifications::Client.new(service_id, secret_id, base_url)
+client.base_url # => Notifications::Client::PRODUCTION_BASE_URL
+```
+
+Generate an API key by logging in to GOV.UK Notify [GOV.UK Notify](https://www.notifications.service.gov.uk) and going to the API integration page.
+
+You will find your service ID on the API integration page.
+
+### Send a message
+
+Text message:
+
+```ruby
+sms = client.send_sms(to: number, 
+                      template: template_id,
+                      personalisation: {
+                      name: "name",
+                      year: "2016"
+  }
+)
+
+```
+
+Email:
+```ruby
+email = client.send_email(to: number, template: template_id)
+
+sms = client.send_sms(
+  to: number,
+  template: template_id,
+  personalisation: {
+    name: "name",
+    year: "2016"
+  }
+) # => Notifications::Client::ResponseNotification
+```
+
+Find `template_id` by clicking **API info** for the template you want to send.
+
+If a template has placeholders, you need to provide their values in `personalisation`. Otherwise do not pass in `personalisation`
+
+If successful the response is a `Notifications::Client::ResponseNotification`, which has the notification id.
+Otherwise a Notifications::Client::RequestError is returned.
+
+
+### Get the status of one message
+
+```ruby
+notification = client.get_notification(id) # => Notifications::Client::Notification
+notification.id         # => uuid for the notification
+notification.to         # => recipient email address or mobile number
+notification.status     # => status of the message "created|pending|sent|delivered|permanent-failure|temporary-failure" 
+notification.created_at # => Date time the message was created
+notification.api_key    # => uuid for the api key (not the actual api key)
+notification.billable_units # => units billable or nil for email
+notification.subject    # => Subject of email or nil for sms
+notification.body       # => Body of message
+notification.job        # => job id if created by a csv or nil if message sent via api
+notification.notification_type # => sms | email
+notification.service    # => uuid for service
+notification.sent_at    # => Date time the message is sent to the provider or nil if status = "created"
+notification.sent_by    # => Name of the provider that sent the message or nil if status = "created"
+notification.template   # => Hash containing template id, name, version, template type sms|email
+notification.template_version # Template version number
+notification.reference  # => reference of the email or nil for sms
+notification.updated_at # => Date time that the notification was last updated
+```
+
+### Get the status of all messages
+
+```ruby
+notifications = client.get_notifications
+notifications.links # => {"last"=>"/notifications?page=4", "next"=>"/notifications?page=2"}
+notifications.total # => 202
+notifications.page_size # => 50
+notifications.collection # => [] (array of notification objects)
+
+```
+
+Query parameters are also supported
+
+```ruby
+client.get_notifications(
+  page: 2,
+  limit_days: 3,
+  page_size: 20,
+  status: "delivered",
+  template_type: "sms"
+)
+```
+
+### Exceptions
+
+Raised exceptions will contain error message and response status code
+
+```ruby
+client = Notifications::Client.new(base_url, invalid, invalid)
+rescue Notifications::Client::RequestError => e
+e.code # => 403
+e.message # => Invalid credentials
+```
+<table>
+  <thead>
+    <tr>
+      <td> Code </td>
+      <td> Message </td>
+     </tr>
+  </thead>
+  <tbdoy>
+  <tr>
+    <td> 403 </td>
+    <td> {"token"=>["Invalid token: signature"]} </td>
+  </tr>
+  <tr>
+    <td> 403 </td>
+    <td> {"token"=>["Invalid token: expired"]} </td>
+  </tr>
+  <tr>
+    <td> 429 </td>
+    <td> Exceeded send limits (50) for today </td>
+  </tr>
+  <tr>
+    <td> 400 </td>
+    <td> Can’t send to this recipient using a team-only API key </td>
+  </tr>
+  <tr>
+    <td> 400 </td>
+    <td> Can’t send to this recipient when service is in trial 
+          mode - see https://www.notifications.service.gov.uk/trial-mode
+    </td>
+  </tr>
+  </tbody>
+</table>

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+
+desc "Run govuk-lint with similar params to CI"
+task "lint" do
+  sh "bundle exec govuk-lint-ruby --format clang spec lib"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "notifications/client"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/test_client.rb

@@ -0,0 +1,182 @@
+#!/usr/bin/env ruby
+require 'notifications/client'
+require 'notifications/client/notification'
+require 'notifications/client/response_notification'
+require 'notifications/client/notification'
+
+def main
+  client = Notifications::Client.new(ENV['SERVICE_ID'], ENV['API_KEY'], ENV['NOTIFY_API_URL'])
+  email_notification = test_send_email_endpoint(client)
+  sms_notification = test_send_sms_endpoint(client)
+  test_get_notification_by_id_endpoint(client, email_notification.id, 'email')
+  test_get_notification_by_id_endpoint(client, sms_notification.id, 'sms')
+  test_get_all_notifications(client, sms_notification.id, email_notification.id)
+  p 'ruby client functional tests pass'
+  exit 0
+end
+
+def test_send_email_endpoint(client)
+  email_resp = client.send_email(to: ENV['FUNCTIONAL_TEST_EMAIL'], template: ENV['EMAIL_TEMPLATE_ID'])
+  test_notification_response_data_type(email_resp, 'email')
+  email_resp
+end
+
+def test_send_sms_endpoint(client)
+  sms_resp = client.send_sms(to: ENV['FUNCTIONAL_TEST_NUMBER'], template: ENV['SMS_TEMPLATE_ID'])
+  test_notification_response_data_type(sms_resp, 'sms')
+  sms_resp
+end
+
+def test_notification_response_data_type(notification, message_type)
+  unless notification.is_a?(Notifications::Client::ResponseNotification) then
+    p 'failed ' + message_type +' response is not a Notifications::Client::ResponseNotification'
+    exit 1
+  end
+  unless notification.id.is_a?(String) then
+    p 'failed '+ message_type + 'id is not a String'
+    exit 1
+  end
+end
+
+def test_get_notification_by_id_endpoint(client, id, message_type)
+  get_notification_response = get_notification_for_id(client, id, message_type)
+  unless get_notification_response.is_a?(Notifications::Client::Notification) then
+    p 'get notification is not a Notifications::Client::Notification for id ' + id
+    exit 1
+  end
+  if message_type == 'email' then
+    field_should_not_be_nil(expected_fields_in_email_resp, get_notification_response, 'send_email')
+    field_should_be_nil(expected_fields_in_email_resp_that_are_nil, get_notification_response, 'send_email')
+  end
+  if message_type == 'sms' then
+    field_should_not_be_nil(expected_fields_in_sms_resp, get_notification_response, 'send_sms')
+    field_should_be_nil(expected_fields_in_sms_resp_that_are_nil, get_notification_response, 'send_sms')
+  end
+end
+
+
+def get_notification_for_id(client, id, message_type)
+  max_attempts = 0
+  wait_for_sent_message = true
+  while max_attempts < 3 && wait_for_sent_message
+    begin
+      get_notification_response = client.get_notification(id)
+      wait_for_sent_message = false
+    rescue Notifications::Client::RequestError => no_result
+      if no_result.message == "No result found"
+        max_attempts = max_attempts + 1
+        sleep 3
+      else
+        p 'get_notification threw an exception for the ' + message_type + ' notification'
+        p no_result.to_s
+        exit 1
+      end
+    end
+    if get_notification_response != nil && get_notification_response.send(:'status') == 'created'
+      # we want to test the sent response?
+      wait_for_sent_message = true
+    end
+  end
+  if max_attempts == 3 then
+    p 'get_notification failed because the ' + message_type + ' notification was not found'
+    exit 1
+  end
+  get_notification_response
+end
+
+def field_should_not_be_nil(fields, obj, method_name)
+  fields.each do |field|
+    if obj.send(:"#{field}") == nil then
+      p 'contract test failed because ' + field + ' should not be nil for ' + method_name + ' response'
+      exit 1
+    end
+  end
+end
+
+def field_should_be_nil(fields, obj, method_name)
+  fields.each do |field|
+    if obj.send(:"#{field}") != nil then
+      p 'contract test failed because ' + field + ' should be nil for ' + method_name + ' response'
+      exit 1
+    end
+  end
+end
+
+def expected_fields_in_email_resp
+  %w(id
+     api_key
+     billable_units
+     to
+     subject
+     body
+     notification_type
+     status
+     service
+     sent_at
+     sent_by
+     template
+     template_version
+     created_at
+     updated_at
+)
+end
+
+def expected_fields_in_email_resp_that_are_nil
+  %w(job)
+end
+
+def expected_fields_in_sms_resp
+  %w(id
+   api_key
+   billable_units
+   to
+   body
+   notification_type
+   status
+   service
+   sent_at
+   sent_by
+   template
+   template_version
+   created_at
+   updated_at
+   )
+end
+
+def expected_fields_in_sms_resp_that_are_nil
+  %w(job
+  subject
+	reference)
+end
+
+def test_get_all_notifications(client, first_id, second_id)
+  notifications = client.get_notifications()
+  unless notifications.is_a?(Notifications::Client::NotificationsCollection) then
+    p 'get all notifications is not Notifications::Client::NotificationsCollection'
+    exit 1
+  end
+
+  field_should_not_be_nil(expected_fields_for_get_all_notifications, notifications, 'get_notifications')
+
+  notification_collection = notifications.send(:'collection')
+  unless notification_collection[0].id == first_id then
+    p 'first item in notification_collection is not the expected notification, last message sent'
+    exit 0
+  end
+  unless notification_collection[1].id == second_id then
+    p 'second item in notification_collection is not the expected notification, second last message sent'
+    exit 0
+  end
+end
+
+def expected_fields_for_get_all_notifications
+  %W(links
+	total
+	page_size
+	collection
+	)
+end
+
+if __FILE__ == $PROGRAM_NAME
+  main
+end

data/lib/notifications/client/notification.rb

@@ -0,0 +1,57 @@
+module Notifications
+  class Client
+    class Notification
+      FIELDS = [
+        :id,
+        :api_key,
+        :billable_units,
+        :to,
+        :subject,
+        :body,
+        :job,
+        :notification_type,
+        :status,
+        :service,
+        :sent_at,
+        :sent_by,
+        :template,
+        :template_version,
+        :reference,
+        :created_at,
+        :updated_at
+      ].freeze
+
+      attr_reader(*FIELDS)
+
+      def initialize(notification)
+        notification = normalize(notification)
+
+        FIELDS.each do |field|
+            instance_variable_set(:"@#{field}", notification.fetch(field.to_s, nil)
+            )
+        end
+      end
+
+      [
+        :sent_at,
+        :created_at,
+        :updated_at
+      ].each do |field|
+        define_method field do
+          begin
+            value = instance_variable_get(:"@#{field}")
+            Time.parse value
+          rescue
+            value
+          end
+        end
+      end
+
+      private
+
+      def normalize(notification)
+        notification.key?('data') ? notification['data']['notification'] : notification
+      end
+    end
+  end
+end

data/lib/notifications/client/notifications_collection.rb

@@ -0,0 +1,23 @@
+module Notifications
+  class Client
+    class NotificationsCollection
+      attr_reader :links,
+                  :total,
+                  :page_size,
+                  :collection
+
+      def initialize(response)
+        @links = response["links"]
+        @total = response["total"]
+        @page_size = response["page_size"]
+        @collection = collection_from(response["notifications"])
+      end
+
+      def collection_from(notifications)
+        notifications.map do |notification|
+          Notification.new(notification)
+        end
+      end
+    end
+  end
+end

data/lib/notifications/client/request_error.rb

@@ -0,0 +1,22 @@
+module Notifications
+  class Client
+    class RequestError < StandardError
+      attr_reader :code, :message
+
+      def initialize(response)
+        @code = response.code
+        @message = message_from(response.body)
+      end
+
+      def to_s
+        "#{code} #{message}"
+      end
+
+      def message_from(body)
+        JSON.parse(body).fetch("message")
+      rescue JSON::ParserError
+        body
+      end
+    end
+  end
+end

data/lib/notifications/client/response_notification.rb

@@ -0,0 +1,11 @@
+module Notifications
+  class Client
+    class ResponseNotification
+      attr_reader :id
+
+      def initialize(response)
+        @id = response["data"]["notification"]["id"]
+      end
+    end
+  end
+end

data/lib/notifications/client/speaker.rb

@@ -0,0 +1,97 @@
+require "net/https"
+require "uri"
+require "jwt"
+require "notifications/client/request_error"
+
+module Notifications
+  class Client
+    class Speaker
+      attr_reader :base_url
+
+      BASE_PATH = "/notifications".freeze
+      USER_AGENT = "NOTIFY-API-RUBY-CLIENT/#{Notifications::Client::VERSION}".freeze
+
+      ##
+      # @param service_id [String] your service
+      #   API identifier
+      # @param secret [String] your service API
+      #   secret
+      # @param base_url [String] host URL. This is
+      #   the address to perform the requests
+      def initialize(service_id, secret_token, base_url = nil)
+        @service_id = service_id
+        @secret_token = secret_token
+        @base_url = base_url || PRODUCTION_BASE_URL
+      end
+
+      ##
+      # @param kind [String] 'email' or 'sms'
+      # @param form_data [Hash]
+      # @option form_data [String] :to recipient
+      #   to notify (sms or email)
+      # @option form_data [String] :template
+      #   template to render in notification
+      # @option form_data [Hash] :personalisation
+      #   fields to use in the template
+      # @see #perform_request!
+      def post(kind, form_data)
+        request = Net::HTTP::Post.new(
+          "#{BASE_PATH}/#{kind}",
+          headers
+        )
+        request.body = form_data.is_a?(Hash) ? form_data.to_json : form_data
+        perform_request!(request)
+      end
+
+      ##
+      # @param id [String]
+      # @param options [Hash] query
+      # @see #perform_request!
+      def get(id = nil, options = {})
+        path = BASE_PATH.dup
+        path << "/" << id if id
+        path << "?" << URI.encode_www_form(options) if options.any?
+        request = Net::HTTP::Get.new(path, headers)
+        perform_request!(request)
+      end
+
+      private
+
+      ##
+      # @return [Hash] JSON parsed response
+      # @raise [RequestError] if request is
+      #   not successful
+      def perform_request!(request)
+        response = open(request)
+        if response.is_a?(Net::HTTPClientError)
+          raise RequestError.new(response)
+        else
+          JSON.parse(response.body)
+        end
+      end
+
+      def open(request)
+        uri = URI.parse(@base_url)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          http.request(request)
+        end
+      end
+
+      def headers
+        {
+          "User-agent" => USER_AGENT,
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer " + jwt_token
+        }
+      end
+
+      def jwt_token
+        payload = {
+          iss: @service_id,
+          iat: Time.now.to_i
+        }
+        JWT.encode payload, @secret_token, "HS256"
+      end
+    end
+  end
+end

data/lib/notifications/client/version.rb

@@ -0,0 +1,5 @@
+module Notifications
+  class Client
+    VERSION = "1.0.0".freeze
+  end
+end

data/lib/notifications/client.rb

@@ -0,0 +1,70 @@
+require "notifications/client/version"
+require "notifications/client/speaker"
+require "notifications/client/notification"
+require "notifications/client/response_notification"
+require "notifications/client/notifications_collection"
+require 'active_support/core_ext/module/delegation'
+
+module Notifications
+  class Client
+    attr_reader :speaker
+
+    PRODUCTION_BASE_URL = "https://api.notifications.service.gov.uk".freeze
+
+    delegate :base_url,
+             :base_url=,
+             to: :speaker
+
+    ##
+    # @see Notifications::Client::Speaker#initialize
+    def initialize(*args)
+      @speaker = Speaker.new(*args)
+    end
+
+    ##
+    # @see Notifications::Client::Speaker#post
+    # @return [ResponseNotification]
+    def send_email(args)
+      ResponseNotification.new(
+        speaker.post("email", args)
+      )
+    end
+
+    ##
+    # @see Notifications::Client::Speaker#post
+    # @return [ResponseNotification]
+    def send_sms(args)
+      ResponseNotification.new(
+        speaker.post("sms", args)
+      )
+    end
+
+    ##
+    # @param id [String]
+    # @see Notifications::Client::Speaker#get
+    # @return [Notification]
+    def get_notification(id)
+      Notification.new(
+        speaker.get(id)
+      )
+    end
+
+    ##
+    # @param options [Hash]
+    # @option options [String] :template_type
+    #   sms or email
+    # @option options [String] :status
+    #   sending, delivered, permanently failed,
+    #   temporarily failed, or technical failure
+    # @option options [String] :page
+    # @option options [String] :page_size
+    # @option options [String] :limit_days
+    # @see Notifications::Client::Speaker#get
+    # @return [NotificationsCollection]
+    def get_notifications(options = {})
+      NotificationsCollection.new(
+        speaker.get(nil, options)
+      )
+    end
+  end
+end

data/notifications-ruby-client.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'notifications/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "notifications-ruby-client"
+  spec.version       = Notifications::Client::VERSION
+  spec.authors       = [
+    "bitzesty",
+    "dazahern"
+  ]
+
+  spec.email         = ["info@bitzesty.com", "daz.ahern@digital.cabinet-office.gov.uk"]
+
+  spec.summary       = "Ruby client for GOV.UK Notifications API"
+  spec.homepage      = "https://github.com/alphagov/notifications-ruby-client"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "jwt", "~> 1.5"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 2.0"
+  spec.add_development_dependency "factory_girl", "~> 4.7"
+  spec.add_development_dependency "govuk-lint", "~> 1.1.0"
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: notifications-ruby-client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- bitzesty
+- dazahern
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: govuk-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+description: 
+email:
+- info@bitzesty.com
+- daz.ahern@digital.cabinet-office.gov.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- bin/test_client.rb
+- lib/notifications/client.rb
+- lib/notifications/client/notification.rb
+- lib/notifications/client/notifications_collection.rb
+- lib/notifications/client/request_error.rb
+- lib/notifications/client/response_notification.rb
+- lib/notifications/client/speaker.rb
+- lib/notifications/client/version.rb
+- notifications-ruby-client.gemspec
+homepage: https://github.com/alphagov/notifications-ruby-client
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby client for GOV.UK Notifications API
+test_files: []