notifications-ruby-client 4.0.0

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/Makefile

@@ -0,0 +1,87 @@
+.DEFAULT_GOAL := help
+SHELL := /bin/bash
+
+DOCKER_BUILDER_IMAGE_NAME = govuk/notify-ruby-client-builder
+
+BUILD_TAG ?= notifications-ruby-client-manual
+
+DOCKER_CONTAINER_PREFIX = ${USER}-${BUILD_TAG}
+
+.PHONY: help
+help:
+	@cat $(MAKEFILE_LIST) | grep -E '^[a-zA-Z_-]+:.*?## .*$$' | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.PHONY: dependencies
+dependencies: ## Install build dependencies
+	bundle install --path=vendor/bundle --binstubs=vendor/bin
+
+.PHONY: build
+build: dependencies ## Build project
+
+.PHONY: test
+test: ## Run tests
+	bundle exec rake spec
+
+.PHONY: integration-test
+integration-test: ## Run integration tests
+	bundle exec bin/test_client.rb
+
+.PHONY: generate-env-file
+generate-env-file: ## Generate the environment file for running the tests inside a Docker container
+	bin/generate_docker_env.sh
+
+.PHONY: prepare-docker-runner-image
+prepare-docker-runner-image: ## Prepare the Docker builder image
+	make -C docker build
+
+.PHONY: build-with-docker
+build-with-docker: prepare-docker-runner-image ## Build inside a Docker container
+	docker run -i --rm \
+		--name "${DOCKER_CONTAINER_PREFIX}-build" \
+		-v "`pwd`:/var/project" \
+		-e http_proxy="${HTTP_PROXY}" \
+		-e HTTP_PROXY="${HTTP_PROXY}" \
+		-e https_proxy="${HTTPS_PROXY}" \
+		-e HTTPS_PROXY="${HTTPS_PROXY}" \
+		-e NO_PROXY="${NO_PROXY}" \
+		${DOCKER_BUILDER_IMAGE_NAME} \
+		make build
+
+.PHONY: test-with-docker
+test-with-docker: prepare-docker-runner-image generate-env-file ## Run tests inside a Docker container
+	docker run -i --rm \
+		--name "${DOCKER_CONTAINER_PREFIX}-test" \
+		-v "`pwd`:/var/project" \
+		-e http_proxy="${HTTP_PROXY}" \
+		-e HTTP_PROXY="${HTTP_PROXY}" \
+		-e https_proxy="${HTTPS_PROXY}" \
+		-e HTTPS_PROXY="${HTTPS_PROXY}" \
+		-e NO_PROXY="${NO_PROXY}" \
+		--env-file docker.env \
+		${DOCKER_BUILDER_IMAGE_NAME} \
+		make test
+
+.PHONY: integration-test-with-docker
+integration-test-with-docker: prepare-docker-runner-image generate-env-file ## Run integration tests inside a Docker container
+	docker run -i --rm \
+		--name "${DOCKER_CONTAINER_PREFIX}-integration-test" \
+		-v "`pwd`:/var/project" \
+		-e http_proxy="${HTTP_PROXY}" \
+		-e HTTP_PROXY="${HTTP_PROXY}" \
+		-e https_proxy="${HTTPS_PROXY}" \
+		-e HTTPS_PROXY="${HTTPS_PROXY}" \
+		-e NO_PROXY="${NO_PROXY}" \
+		--env-file docker.env \
+		${DOCKER_BUILDER_IMAGE_NAME} \
+		make integration-test
+
+.PHONY: clean-docker-containers
+clean-docker-containers: ## Clean up any remaining docker containers
+	docker rm -f $(shell docker ps -q -f "name=${DOCKER_CONTAINER_PREFIX}") 2> /dev/null || true
+
+.PHONY: run-govuk-lint
+run-govuk-lint: ## Runs GOVUK-lint for Ruby
+	bundle exec govuk-lint-ruby lib spec bin/test_client 
+
+clean:
+	rm -rf vendor

data/README.md

@@ -0,0 +1,10 @@
+# GOV.UK Notify Ruby client
+
+Use this client to send emails, text messages and letters using the [GOV.UK Notify](https://www.notifications.service.gov.uk) API.
+
+Useful links:
+
+- [Documentation](https://docs.notifications.service.gov.uk/ruby.html)
+- [Ruby gem](https://rubygems.org/gems/notifications-ruby-client)
+- [Changelog](https://github.com/alphagov/notifications-ruby-client/blob/master/CHANGELOG.md)
+- [Contributing to this client](https://github.com/alphagov/notifications-ruby-client/blob/master/CONTRIBUTING.md)

data/Rakefile

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

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/generate_docker_env.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+
+set -eo pipefail
+
+function exit_with_msg {
+    echo $1
+    exit $2
+}
+
+echo -n "" > docker.env
+
+env_vars=(
+    NOTIFY_API_URL
+    SERVICE_ID
+    API_KEY
+    FUNCTIONAL_TEST_EMAIL
+    FUNCTIONAL_TEST_NUMBER
+    EMAIL_TEMPLATE_ID
+    SMS_TEMPLATE_ID
+    LETTER_TEMPLATE_ID
+    EMAIL_REPLY_TO_ID
+    SMS_SENDER_ID
+    API_SENDING_KEY
+    INBOUND_SMS_QUERY_KEY
+)
+
+for env_var in "${env_vars[@]}"; do
+    echo "${env_var}=${!env_var}" >> docker.env
+done

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,454 @@
+#!/usr/bin/env ruby
+require './lib/notifications/client'
+
+def main
+  client = Notifications::Client.new(ENV['API_KEY'], ENV['NOTIFY_API_URL'])
+  test_get_template_by_id(client, ENV['EMAIL_TEMPLATE_ID'])
+  test_get_template_version(client, ENV['SMS_TEMPLATE_ID'], 1)
+  test_get_all_templates(client)
+  test_get_all_templates_filter_by_type(client)
+  test_generate_template_preview(client, ENV['EMAIL_TEMPLATE_ID'])
+  email_notification = test_send_email_endpoint(client)
+  email_notification_with_document = test_send_email_endpoint_with_document(client)
+  sms_notification = test_send_sms_endpoint(client)
+  letter_notification = test_send_letter_endpoint(client)
+  precompiled_letter_notification = test_send_precompiled_letter_endpoint(client)
+  test_get_notification_by_id_endpoint(client, email_notification.id, 'email')
+  test_get_notification_by_id_endpoint(client, email_notification_with_document.id, 'email')
+  test_get_notification_by_id_endpoint(client, sms_notification.id, 'sms')
+  test_get_notification_by_id_endpoint(client, letter_notification.id, 'letter')
+  test_get_notification_by_id_endpoint(client, precompiled_letter_notification.id, 'precompiled_letter')
+  test_get_all_notifications(client)
+  test_get_received_texts
+  p 'ruby client integration tests pass'
+  exit 0
+end
+
+def test_get_template_by_id(client, id)
+  response = client.get_template_by_id(id)
+  test_template_response(response, 'test_get_template_by_id')
+end
+
+def test_get_template_version(client, id, version)
+  response = client.get_template_version(id, version)
+  test_template_response(response, 'test_get_template_version')
+end
+
+def test_get_all_templates(client)
+  response = client.get_all_templates
+  unless response.is_a?(Notifications::Client::TemplateCollection)
+    p 'failed test_get_all_templates response is not a Notifications::Client::TemplateCollection'
+    exit 1
+  end
+  unless response.collection.length >= 3
+    p 'failed test_get_all_templates, expected at least 3 templates returned.'
+    exit 1
+  end
+  test_template_response(response.collection[0], 'test_get_all_templates')
+  test_template_response(response.collection[1], 'test_get_all_templates')
+  test_template_response(response.collection[2], 'test_get_all_templates')
+end
+
+def test_get_all_templates_filter_by_type(client)
+  response = client.get_all_templates('type' => 'sms')
+  unless response.is_a?(Notifications::Client::TemplateCollection)
+    p 'failed test_get_all_templates response is not a Notifications::Client::TemplateCollection'
+    exit 1
+  end
+  unless response.collection.length >= 1
+    p 'failed test_get_all_templates, expected at least 2 templates returned.'
+    exit 1
+  end
+  test_template_response(response.collection[0], 'test_get_all_templates')
+end
+
+def test_generate_template_preview(client, id)
+  response = client.generate_template_preview(id, personalisation: { "name" => "some name" })
+  test_template_preview(response)
+end
+
+def test_template_response(response, test_method)
+  unless response.is_a?(Notifications::Client::Template)
+    p 'failed test_get_template_by_id response is not a Notifications::Client::Template'
+    exit 1
+  end
+  unless response.id.is_a?(String)
+    p 'failed template id is not a String'
+    exit 1
+  end
+  field_should_not_be_nil(expected_fields_in_template_response, response, test_method)
+end
+
+def test_template_preview(response)
+  unless response.is_a?(Notifications::Client::TemplatePreview)
+    p 'failed test_generate_template_preview response is not a Notifications::Client::TemplatePreview'
+    exit 1
+  end
+  unless response.id.is_a?(String)
+    p 'failed template id is not a String'
+    exit 1
+  end
+  field_should_not_be_nil(expected_fields_in_template_preview, response, 'generate_template_preview')
+end
+
+def test_send_email_endpoint(client)
+  email_resp = client.send_email(email_address: ENV['FUNCTIONAL_TEST_EMAIL'],
+                                 template_id: ENV['EMAIL_TEMPLATE_ID'],
+                                 personalisation: { "name" => "some name" },
+                                 reference: "some reference",
+                                 email_reply_to_id: ENV['EMAIL_REPLY_TO_ID'])
+  test_notification_response_data_type(email_resp, 'email')
+  email_resp
+end
+
+def test_send_email_endpoint_with_document(client)
+  email_resp = File.open('spec/test_files/test_pdf.pdf', 'rb') do |f|
+    client.send_email(email_address: ENV['FUNCTIONAL_TEST_EMAIL'],
+      template_id: ENV['EMAIL_TEMPLATE_ID'],
+      personalisation: { name: Notifications.prepare_upload(f) },
+      reference: "some reference",
+      email_reply_to_id: ENV['EMAIL_REPLY_TO_ID'])
+  end
+
+  test_notification_response_data_type(email_resp, 'email')
+  email_resp
+end
+
+def test_send_sms_endpoint(client)
+  sms_resp = client.send_sms(phone_number: ENV['FUNCTIONAL_TEST_NUMBER'], template_id: ENV['SMS_TEMPLATE_ID'],
+                             personalisation: { "name" => "some name" },
+                             reference: "some reference",
+                             sms_sender_id: ENV['SMS_SENDER_ID'])
+  test_notification_response_data_type(sms_resp, 'sms')
+  sms_resp
+end
+
+def test_send_letter_endpoint(client)
+  letter_resp = client.send_letter(
+    template_id: ENV['LETTER_TEMPLATE_ID'],
+    personalisation: {
+      address_line_1: "Her Majesty The Queen",
+      address_line_2: "Buckingham Palace",
+      postcode: "SW1 1AA"
+    },
+    reference: "some reference"
+  )
+  test_notification_response_data_type(letter_resp, 'letter')
+  letter_resp
+end
+
+def test_send_precompiled_letter_endpoint(client)
+  precompiled_letter_resp = File.open('spec/test_files/test_pdf.pdf', 'rb') do |file|
+    client.send_precompiled_letter("some reference", file, "first")
+  end
+
+  test_notification_response_data_type(precompiled_letter_resp, 'precompiled_letter')
+
+  precompiled_letter_resp
+end
+
+def test_notification_response_data_type(notification, message_type)
+  unless notification.is_a?(Notifications::Client::ResponseNotification) || (notification.is_a?(Notifications::Client::ResponsePrecompiledLetter) && message_type == "precompiled_letter")
+    p 'failed ' + message_type + ' response is not a Notifications::Client::ResponseNotification'
+    exit 1
+  end
+  unless notification.id.is_a?(String)
+    p 'failed ' + message_type + 'id is not a String'
+    exit 1
+  end
+
+  if message_type == 'precompiled_letter'
+    field_should_not_be_nil(expected_fields_in_precompiled_letter_response, notification, 'send_precompiled_letter')
+    if notification.postage != "first"
+      p "Postage should be set to 'first' for precompiled letter sending test. Right now it is set to #{notification.postage}"
+      exit 1
+    end
+    return
+  end
+
+  field_should_not_be_nil(expected_fields_in_notification_response, notification, 'send_' + message_type)
+  hash_key_should_not_be_nil(expected_fields_in_template, notification.send('template'), 'send_' + message_type + '.template')
+
+  if message_type == 'email'
+    hash_key_should_not_be_nil(expected_fields_in_email_content, notification.send('content'), 'send_' + message_type + '.content')
+  elsif message_type == 'sms'
+    hash_key_should_not_be_nil(expected_fields_in_sms_content, notification.send('content'), 'send_' + message_type + '.content')
+  elsif message_type == 'letter'
+    hash_key_should_not_be_nil(expected_fields_in_letter_content, notification.send('content'), 'send_' + message_type + '.content')
+  end
+end
+
+def test_get_notification_by_id_endpoint(client, id, message_type)
+  get_notification_response = client.get_notification(id)
+
+  unless get_notification_response.is_a?(Notifications::Client::Notification)
+    p 'get notification is not a Notifications::Client::Notification for id ' + id
+    exit 1
+  end
+
+  if message_type == 'email'
+    field_should_not_be_nil(expected_fields_in_email_notification, get_notification_response, 'Notifications::Client::Notification for type email')
+    field_should_be_nil(expected_fields_in_email_notification_that_are_nil, get_notification_response, 'Notifications::Client::Notification for type email')
+    hash_key_should_not_be_nil(expected_fields_in_template, get_notification_response.send('template'), 'Notifications::Client::Notification.template for type email')
+  elsif message_type == 'sms'
+    field_should_not_be_nil(expected_fields_in_sms_notification, get_notification_response, 'Notifications::Client::Notification for type sms')
+    field_should_be_nil(expected_fields_in_sms_notification_that_are_nil, get_notification_response, 'Notifications::Client::Notification for type sms')
+    hash_key_should_not_be_nil(expected_fields_in_template, get_notification_response.send('template'), 'Notifications::Client::Notification.template for type sms')
+  elsif message_type == 'letter'
+    field_should_not_be_nil(expected_fields_in_letter_notification, get_notification_response, 'Notifications::Client::Notification for type letter')
+    field_should_be_nil(expected_fields_in_letter_notification_that_are_nil, get_notification_response, 'Notifications::Client::Notification for type letter')
+    hash_key_should_not_be_nil(expected_fields_in_template, get_notification_response.send('template'), 'Notifications::Client::Notification.template for type letter')
+  elsif message_type == 'precompiled_letter'
+    field_should_not_be_nil(expected_fields_in_precompiled_letter_notification, get_notification_response, 'Notifications::Client::Notification for type precompiled letter')
+    field_should_be_nil(expected_fields_in_precompiled_letter_notification_that_are_nil, get_notification_response, 'Notifications::Client::Notification for type precompiled letter')
+    hash_key_should_not_be_nil(expected_fields_in_template, get_notification_response.send('template'), 'Notifications::Client::Notification.template for type precompiled letter')
+  end
+end
+
+def hash_key_should_not_be_nil(fields, obj, method_name)
+  fields.each do |field|
+    if obj.has_value?(:"#{field}")
+      p 'contract test failed because ' + field + ' should not be nil for ' + method_name + ' response'
+      exit 1
+    end
+  end
+end
+
+def field_should_not_be_nil(fields, obj, method_name)
+  fields.each do |field|
+    if obj.send(:"#{field}") == nil
+      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
+      p 'contract test failed because ' + field + ' should be nil for ' + method_name + ' response'
+      exit 1
+    end
+  end
+end
+
+def expected_fields_in_template_response
+  %w(id
+     name
+     type
+     created_at
+     created_by
+     body
+     version)
+end
+
+def expected_fields_in_template_preview
+  %w(id
+     body
+     version
+     type
+     html)
+end
+
+def expected_fields_in_notification_response
+  %w(id
+     reference
+     content
+     template
+     uri)
+end
+
+def expected_fields_in_precompiled_letter_response
+  %w(id
+     reference
+     postage)
+end
+
+def expected_fields_in_email_content
+  %w(from_email
+     body
+     subject)
+end
+
+def expected_fields_in_sms_content
+  %w(body
+    from_number)
+end
+
+def expected_fields_in_letter_content
+  %w(
+    body
+    subject
+  )
+end
+
+def expected_fields_in_email_notification
+  %w(id
+     email_address
+     type
+     status
+     template
+     body
+     subject
+     created_at)
+end
+
+def expected_fields_in_email_notification_that_are_nil
+  %w(phone_number
+     line_1
+     line_2
+     line_3
+     line_4
+     line_5
+     line_5
+     line_6
+     postcode
+     created_by_name
+     postage)
+end
+
+def expected_fields_in_sms_notification
+  %w(id
+     phone_number
+     type
+     status
+     template
+     body
+     created_at)
+end
+
+def expected_fields_in_sms_notification_that_are_nil
+  %w(email_address
+     line_1
+     line_2
+     line_3
+     line_4
+     line_5
+     line_5
+     line_6
+     postcode
+     subject
+     created_by_name
+     postage)
+end
+
+def expected_fields_in_letter_notification
+  %w(
+    id
+    type
+    status
+    template
+    body
+    subject
+    line_1
+    line_2
+    postcode
+    created_at
+    postage
+  )
+end
+
+def expected_fields_in_letter_notification_that_are_nil
+  %w(
+    phone_number
+    email_address
+    line_3
+    line_4
+    line_5
+    line_5
+    line_6
+    created_by_name
+  )
+end
+
+def expected_fields_in_precompiled_letter_notification
+  %w(
+    body
+    created_at
+    id
+    line_1
+    reference
+    status
+    subject
+    template
+    type
+    postage
+  )
+end
+
+def expected_fields_in_precompiled_letter_notification_that_are_nil
+  %w(
+    completed_at
+    created_by_name
+    email_address
+    line_2
+    line_3
+    line_4
+    line_5
+    line_6
+    phone_number
+    postcode
+    sent_at
+  )
+end
+
+def expected_fields_in_template
+  %w(id
+     version
+     uri)
+end
+
+def expected_fields_in_received_text_response
+  %w(id
+     created_at
+     content
+     notify_number
+     service_id
+     user_number)
+end
+
+def test_get_all_notifications(client)
+  notifications = client.get_notifications
+  unless notifications.is_a?(Notifications::Client::NotificationsCollection)
+    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')
+end
+
+def test_get_received_texts
+  client = Notifications::Client.new(ENV['INBOUND_SMS_QUERY_KEY'], ENV['NOTIFY_API_URL'])
+  response = client.get_received_texts
+  unless response.is_a?(Notifications::Client::ReceivedTextCollection)
+    p 'failed test_get_received_texts response is not a Notifications::Client::ReceivedTextCollection'
+    exit 1
+  end
+  unless response.collection.length >= 0
+    p 'failed test_get_received_texts, expected at least 1 received text returned.'
+    exit 1
+  end
+  test_received_text_response(response.collection[0], 'test_received_text_response')
+  test_received_text_response(response.collection[1], 'test_received_text_response')
+  test_received_text_response(response.collection[2], 'test_received_text_response')
+end
+
+def test_received_text_response(response, test_method)
+  unless response.is_a?(Notifications::Client::ReceivedText)
+    p 'failed test_get_received_texts response is not a Notifications::Client::ReceivedText'
+    exit 1
+  end
+  unless response.id.is_a?(String)
+    p 'failed received text id is not a String'
+    exit 1
+  end
+  field_should_not_be_nil(expected_fields_in_received_text_response, response, test_method)
+end
+
+def expected_fields_for_get_all_notifications
+  %W(links
+     collection)
+end
+
+if __FILE__ == $PROGRAM_NAME
+  main
+end