gds-api-adapters 46.0.0 → 47.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 161ffa498afd13048d7be1e30938b3ad067f3acb
-  data.tar.gz: b8f8ae98f0f20ef2cf53631fef4ced003453ffdf
+  metadata.gz: 99be45080ed4287d5b398d1ef0040dc61a74d822
+  data.tar.gz: 13e88395ee04b4d40edd6f76912a946fbcd162c4
 SHA512:
-  metadata.gz: a9e1596dd63611d1928818f2ad3106831909346915252f449f35c2ff0c8df8368eefce31d91c01567595012cfd51efe51f82cffe4dbed8c4955f6f1d5ffcda90
-  data.tar.gz: cf34fcefdbb3e5666c0e66949cb5058f70d9b6e919d8cf94803ea696301d97a436054b2e1115c5d648f0b8e05e201388cf11cfea0cd92d8402ecb245088a1f1b
+  metadata.gz: 3d56fdf001acca6e91cb36e0eb9ff850c1183b6e6d774ede515aa1482769ab9a05fad70cf225265442dd247b83790c10e7d34d0e246ecb64ef543437f6663f70
+  data.tar.gz: 19920ce300008797ce38efcea67ce18897fbd2505216135f225c59e3cbccd78840b09f33ff89a6f80f6c6270fdcbc5933885dac7d3bb8a48d7c771a721cbb3e4

data/lib/gds_api/helpers.rb

@@ -1,5 +1,4 @@
 require 'gds_api/asset_manager'
-require 'gds_api/content_api'
 require 'gds_api/content_store'
 require 'gds_api/imminence'
 require 'gds_api/licence_application'
@@ -13,10 +12,6 @@ module GdsApi
       @asset_manager_api ||= GdsApi::AssetManager.new(Plek.current.find('asset-manager'), options)
     end
 
-    def content_api(options = {})
-      @content_api ||= GdsApi::ContentApi.new(Plek.current.find("contentapi"), options)
-    end
-
     def content_store(options = {})
       @content_store ||= GdsApi::ContentStore.new(Plek.current.find("content-store"), options)
     end
@@ -43,7 +38,7 @@ module GdsApi
 
     def self.included(klass)
       if klass.respond_to?(:helper_method)
-        klass.helper_method :imminence_api, :content_api, :licence_application_api
+        klass.helper_method :imminence_api, :licence_application_api
       end
     end
   end

data/lib/gds_api/list_response.rb

@@ -21,10 +21,7 @@ module GdsApi
     def_delegators :results, :each, :to_ary
 
     def results
-      # support group_by results from the content api by checking if there is a
-      # grouped_results key present first. if it's not, then fallback to the
-      # results key
-      to_hash["grouped_results"] || to_hash["results"]
+      to_hash["results"]
     end
 
     def has_next_page?

data/lib/gds_api/performance_platform/data_out.rb

@@ -43,6 +43,89 @@ module GdsApi
       def service_feedback(transaction_page_slug)
         get_json("#{endpoint}/data/#{transaction_page_slug}/customer-satisfaction")
       end
+
+      # Fetching statistics data from the performance platform for a given page slug
+      #
+      # Makes a +GET+ request.
+      #
+      # @param slug [String] Points to the page for which we are requesting
+      # statistics.
+      # @param is_multipart [Boolean] Flag that marks whether the slug is multipart
+      # or not:
+      #
+      # - simple: `/european-health-insurance-card`
+      # - multipart: `/european-health-insurance-card/123`
+      #
+      # # @examples
+      #
+      #  1. Without multipart filtering:
+      #
+      #  performance_platform_data_out.search_terms('/european-health-insurance-card')
+      #
+      #  2. With multipart filtering:
+      #
+      #  performance_platform_data_out.searches('/european-health-insurance-card', true)
+      #  performance_platform_data_out.page_views('/european-health-insurance-card', true)
+      #  performance_platform_data_out.problem_reports('/european-health-insurance-card', true)
+
+      def search_terms(slug)
+        options = {
+            slug: slug,
+            transaction: 'searchTerms',
+            group_by: 'searchKeyword',
+            collect: 'searchUniques:sum'
+        }
+        statistics(options)
+      end
+
+      def searches(slug, is_multipart)
+        options = {
+            slug: slug,
+            transaction: 'searchTerms',
+            group_by: 'pagePath',
+            collect: 'searchUniques:sum'
+        }
+        statistics(options, is_multipart)
+      end
+
+      def page_views(slug, is_multipart)
+        options = {
+            slug: slug,
+            transaction: 'page-statistics',
+            group_by: 'pagePath',
+            collect: 'uniquePageviews:sum'
+        }
+        statistics(options, is_multipart)
+      end
+
+      def problem_reports(slug, is_multipart)
+        options = {
+            slug: slug,
+            transaction: 'page-contacts',
+            group_by: 'pagePath',
+            collect: 'total:sum'
+        }
+        statistics(options, is_multipart)
+      end
+
+      # This can be used as a free form call to the performance platform.
+      # The performance platform uses Backdrop and its query language for
+      # storing and querying data.
+      # Backdrop can be found here: https://github.com/alphagov/backdrop
+      def statistics(options, is_multipart = false)
+        params = {
+            group_by: options[:group_by],
+            collect: options[:collect],
+            duration: 42,
+            period: "day",
+            end_at: Date.today.to_time.getutc.iso8601
+        }
+
+        filter_param = is_multipart ? :filter_by_prefix : :filter_by
+        params[filter_param] = "pagePath:" + options[:slug]
+
+        get_json("#{endpoint}/data/govuk-info/#{options[:transaction]}#{query_string(params)}")
+      end
     end
   end
 end

data/lib/gds_api/test_helpers/performance_platform/data_out.rb

@@ -17,6 +17,81 @@ module GdsApi
         def stub_service_not_available
           stub_request(:any, /#{PP_DATA_OUT_ENDPOINT}\/.*/).to_return(status: 503)
         end
+
+        def stub_search_terms(slug, response_body = {})
+          options = {
+              slug: slug,
+              transaction: 'searchTerms',
+              group_by: 'searchKeyword',
+              collect: 'searchUniques:sum'
+          }
+          stub_statistics(options, false, response_body)
+        end
+
+        def stub_searches(slug, is_multipart, response_body = {})
+          options = {
+              slug: slug,
+              transaction: 'searchTerms',
+              group_by: 'pagePath',
+              collect: 'searchUniques:sum'
+          }
+          stub_statistics(options, is_multipart, response_body)
+        end
+
+        def stub_page_views(slug, is_multipart, response_body = {})
+          options = {
+              slug: slug,
+              transaction: 'page-statistics',
+              group_by: 'pagePath',
+              collect: 'uniquePageviews:sum'
+          }
+          stub_statistics(options, is_multipart, response_body)
+        end
+
+        def stub_problem_reports(slug, is_multipart, response_body = {})
+          options = {
+              slug: slug,
+              transaction: 'page-contacts',
+              group_by: 'pagePath',
+              collect: 'total:sum'
+          }
+          stub_statistics(options, is_multipart, response_body)
+        end
+
+        def stub_statistics(options, is_multipart, response_body = {})
+          params = {
+              group_by: options[:group_by],
+              collect: options[:collect],
+              duration: 42,
+              period: "day",
+              end_at: Date.today.to_time.getutc.iso8601
+          }
+
+          filter_param = is_multipart ? :filter_by_prefix : :filter_by
+          params[filter_param] = "pagePath:" + options[:slug]
+
+          stub_http_request(:get, "#{PP_DATA_OUT_ENDPOINT}/data/govuk-info/#{options[:transaction]}")
+              .with(query: params)
+              .to_return(status: 200, body: response_body.to_json)
+        end
+
+        def stub_search_404(slug)
+          stub_request(:get, "#{PP_DATA_OUT_ENDPOINT}/data/govuk-info/searchTerms").
+              with(query: hash_including(filter_by: slug)).
+              to_return(status: 404, headers: { content_type: "application/json" })
+        end
+
+        def stub_page_views_404(slug)
+          stub_request(:get, "#{PP_DATA_OUT_ENDPOINT}/data/govuk-info/page-statistics").
+              with(query: hash_including(filter_by: slug)).
+              to_return(status: 404, headers: { content_type: "application/json" })
+        end
+
+        def stub_problem_reports_404(slug)
+          stub_request(:get, "#{PP_DATA_OUT_ENDPOINT}/data/govuk-info/page-contacts").
+              with(query: hash_including(filter_by: slug)).
+              to_return(status: 404, headers: { content_type: "application/json" })
+        end
       end
     end
   end

data/lib/gds_api/version.rb

@@ -1,3 +1,3 @@
 module GdsApi
-  VERSION = '46.0.0'.freeze
+  VERSION = '47.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gds-api-adapters
 version: !ruby/object:Gem::Version
-  version: 46.0.0
+  version: 47.0.0
 platform: ruby
 authors:
 - James Stewart
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-18 00:00:00.000000000 Z
+date: 2017-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: plek
@@ -359,7 +359,6 @@ files:
 - lib/gds_api/asset_manager.rb
 - lib/gds_api/base.rb
 - lib/gds_api/calendars.rb
-- lib/gds_api/content_api.rb
 - lib/gds_api/content_store.rb
 - lib/gds_api/email_alert_api.rb
 - lib/gds_api/exceptions.rb
@@ -392,8 +391,6 @@ files:
 - lib/gds_api/test_helpers/asset_manager.rb
 - lib/gds_api/test_helpers/calendars.rb
 - lib/gds_api/test_helpers/common_responses.rb
-- lib/gds_api/test_helpers/content_api.rb
-- lib/gds_api/test_helpers/content_api/artefact_stub.rb
 - lib/gds_api/test_helpers/content_item_helpers.rb
 - lib/gds_api/test_helpers/content_store.rb
 - lib/gds_api/test_helpers/email_alert_api.rb

data/lib/gds_api/content_api.rb

@@ -1,125 +0,0 @@
-require_relative 'base'
-require_relative 'exceptions'
-require_relative 'list_response'
-
-class GdsApi::ContentApi < GdsApi::Base
-  def initialize(endpoint_url, options = {})
-    # If the `web_urls_relative_to` option is given, the adapter will convert
-    # any `web_url` values to relative URLs if they are from the same host.
-    #
-    # For example: "https://www.gov.uk"
-
-    @web_urls_relative_to = options.delete(:web_urls_relative_to)
-    super
-  end
-
-  def sections
-    tags("section")
-  end
-
-  def root_sections
-    root_tags("section")
-  end
-
-  def sub_sections(parent_tag)
-    child_tags("section", parent_tag)
-  end
-
-  def tags(tag_type, options = {})
-    params = [
-      "type=#{CGI.escape(tag_type)}"
-    ]
-    params << "sort=#{options[:sort]}" if options.has_key?(:sort)
-    params << "draft=true" if options[:draft]
-    params << "cachebust=#{Time.now.utc.to_i}#{rand(1000)}" if options[:bust_cache]
-
-    get_list("#{base_url}/tags.json?#{params.join('&')}")
-  end
-
-  def root_tags(tag_type)
-    get_list("#{base_url}/tags.json?type=#{CGI.escape(tag_type)}&root_sections=true")
-  end
-
-  def child_tags(tag_type, parent_tag, options = {})
-    params = [
-      "type=#{CGI.escape(tag_type)}",
-      "parent_id=#{CGI.escape(parent_tag)}",
-    ]
-    params << "sort=#{options[:sort]}" if options.has_key?(:sort)
-
-    get_list("#{base_url}/tags.json?#{params.join('&')}")
-  end
-
-  def tag(tag, tag_type = nil)
-    if tag_type.nil?
-      raise "Requests for tags without a tag_type are no longer supported. You probably want a tag_type of 'section'. See https://github.com/alphagov/govuk_content_api/blob/f4c0102a1ae4970be6a440707b89798442f768b9/govuk_content_api.rb#L241-L250"
-    end
-
-    url = [base_url, "tags", CGI.escape(tag_type), CGI.escape(tag)].join("/") + ".json"
-    get_json(url)
-  end
-
-  def for_need(need_id)
-    get_list("#{base_url}/for_need/#{CGI.escape(need_id.to_s)}.json")
-  end
-
-  def artefact(slug, params = {})
-    get_json(artefact_url(slug, params))
-  end
-
-  def artefact!(slug, params = {})
-    get_json(artefact_url(slug, params))
-  end
-
-  def artefacts
-    get_list("#{base_url}/artefacts.json")
-  end
-
-  def local_authority(snac_code)
-    get_json("#{base_url}/local_authorities/#{CGI.escape(snac_code)}.json")
-  end
-
-  def local_authorities_by_name(name)
-    get_json("#{base_url}/local_authorities.json?name=#{CGI.escape(name)}")
-  end
-
-  def local_authorities_by_snac_code(snac_code)
-    get_json("#{base_url}/local_authorities.json?snac_code=#{CGI.escape(snac_code)}")
-  end
-
-  def get_list(url)
-    get_json(url) { |r|
-      GdsApi::ListResponse.new(r, self, web_urls_relative_to: @web_urls_relative_to)
-    }
-  end
-
-  def get_json(url, &create_response)
-    create_response = create_response || Proc.new { |r|
-      GdsApi::Response.new(r, web_urls_relative_to: @web_urls_relative_to)
-    }
-    super(url, &create_response)
-  end
-
-private
-
-  def base_url
-    endpoint
-  end
-
-  def key_for_tag_type(tag_type)
-    tag_type.nil? ? "tag" : CGI.escape(tag_type)
-  end
-
-  def artefact_url(slug, params)
-    url = "#{base_url}/#{CGI.escape(slug)}.json"
-    query = params.map { |k, v| "#{k}=#{v}" }
-    if query.any?
-      url += "?#{query.join('&')}"
-    end
-
-    if params[:edition] && ! options.include?(:bearer_token)
-      raise GdsApi::NoBearerToken
-    end
-    url
-  end
-end

data/lib/gds_api/test_helpers/content_api.rb

@@ -1,358 +0,0 @@
-require 'gds_api/test_helpers/json_client_helper'
-require 'cgi'
-require 'gds_api/test_helpers/common_responses'
-
-module GdsApi
-  module TestHelpers
-    module ContentApi
-      include GdsApi::TestHelpers::CommonResponses
-      # Generally true. If you are initializing the client differently,
-      # you could redefine/override the constant or stub directly.
-      CONTENT_API_ENDPOINT = Plek.current.find('contentapi')
-
-      # Legacy section test helpers
-      #
-      # Use of these should be retired in favour of the other test helpers in this
-      # module which work with any tag type.
-
-      def content_api_has_root_sections(slugs_or_sections)
-        content_api_has_root_tags("section", slugs_or_sections)
-      end
-
-      def content_api_has_section(slug_or_hash, parent_slug = nil)
-        content_api_has_tag("section", slug_or_hash, parent_slug)
-      end
-
-      def content_api_has_subsections(parent_slug_or_hash, subsection_slugs)
-        content_api_has_child_tags("section", parent_slug_or_hash, subsection_slugs)
-      end
-
-      def artefact_for_slug_in_a_section(slug, section_slug)
-        artefact_for_slug_with_a_tag("section", slug, section_slug)
-      end
-
-      def artefact_for_slug_in_a_subsection(slug, subsection_slug)
-        artefact_for_slug_with_a_child_tag("section", slug, subsection_slug)
-      end
-
-      # Takes an array of slugs, or hashes with section details (including a slug).
-      # Will stub out content_api calls for tags of type section to return these sections
-      def content_api_has_root_tags(tag_type, slugs_or_tags)
-        body = plural_response_base.merge(
-          "results" => slugs_or_tags.map { |tag| tag_result(tag, tag_type) }
-        )
-        urls = ["type=#{tag_type}", "root_sections=true&type=#{tag_type}"].map { |q|
-          "#{CONTENT_API_ENDPOINT}/tags.json?#{q}"
-        }
-        urls.each do |url|
-          stub_request(:get, url).to_return(status: 200, body: body.to_json, headers: {})
-        end
-      end
-
-      def content_api_has_tag(tag_type, slug_or_hash, parent_tag_id = nil)
-        tag = tag_hash(slug_or_hash, tag_type).merge(parent: parent_tag_id)
-        body = tag_result(tag)
-
-        urls = ["#{CONTENT_API_ENDPOINT}/tags/#{CGI.escape(tag_type)}/#{CGI.escape(tag[:slug])}.json"]
-
-        urls.each do |url|
-          stub_request(:get, url).to_return(status: 200, body: body.to_json, headers: {})
-        end
-      end
-
-      def content_api_does_not_have_tag(tag_type, slug)
-        body = {
-          "_response_info" => {
-            "status" => "not found"
-          }
-        }
-
-        urls = ["#{CONTENT_API_ENDPOINT}/tags/#{CGI.escape(tag_type)}/#{CGI.escape(slug)}.json"]
-
-        urls.each do |url|
-          stub_request(:get, url).to_return(status: 404, body: body.to_json, headers: {})
-        end
-      end
-
-      def content_api_has_draft_and_live_tags(options = {})
-        type = options.fetch(:type)
-        live_tags = options.fetch(:live).map { |tag| tag_result(tag, type, state: 'live') }
-        draft_tags = options.fetch(:draft).map { |tag| tag_result(tag, type, state: 'draft') }
-
-        body = plural_response_base.merge("results" => live_tags)
-        stub_request(:get, "#{CONTENT_API_ENDPOINT}/tags.json")
-          .with(query: hash_including("type" => type))
-          .to_return(status: 200, body: body.to_json, headers: {})
-
-        body = plural_response_base.merge("results" => (live_tags + draft_tags))
-        stub_request(:get, "#{CONTENT_API_ENDPOINT}/tags.json")
-          .with(query: hash_including("type" => type, "draft" => "true"))
-          .to_return(status: 200, body: body.to_json, headers: {})
-      end
-
-      def content_api_does_not_have_tags(tag_type, _slugs)
-        body = {
-          "_response_info" => {
-            "status" => "not found"
-          }
-        }
-
-        stub_request(:get, "#{CONTENT_API_ENDPOINT}/tags.json")
-          .with(query: hash_including("type" => tag_type))
-          .to_return(status: 404, body: body.to_json, headers: {})
-      end
-
-      def content_api_has_tags(tag_type, slugs_or_tags)
-        body = plural_response_base.merge(
-          "results" => slugs_or_tags.map { |tag| tag_result(tag, tag_type) }
-        )
-
-        stub_request(:get, "#{CONTENT_API_ENDPOINT}/tags.json")
-          .with(query: hash_including("type" => tag_type))
-          .to_return(status: 200, body: body.to_json, headers: {})
-      end
-
-      def content_api_has_sorted_tags(tag_type, sort_order, slugs_or_tags)
-        body = plural_response_base.merge(
-          "results" => slugs_or_tags.map { |tag| tag_result(tag, tag_type) }
-        )
-
-        stub_request(:get, "#{CONTENT_API_ENDPOINT}/tags.json")
-          .with(query: hash_including("type" => tag_type, "sort" => sort_order))
-          .to_return(status: 200, body: body.to_json, headers: {})
-      end
-
-      def content_api_has_child_tags(tag_type, parent_slug_or_hash, child_tag_ids)
-        parent_tag = tag_hash(parent_slug_or_hash, tag_type)
-        child_tags = child_tag_ids.map { |id|
-          tag_hash(id, tag_type).merge(parent: parent_tag)
-        }
-        body = plural_response_base.merge(
-          "results" => child_tags.map { |s| tag_result(s, tag_type) }
-        )
-        url = "#{CONTENT_API_ENDPOINT}/tags.json?type=#{tag_type}&parent_id=#{CGI.escape(parent_tag[:slug])}"
-        stub_request(:get, url).to_return(status: 200, body: body.to_json, headers: {})
-      end
-
-      def content_api_has_sorted_child_tags(tag_type, parent_slug_or_hash, sort_order, child_tag_ids)
-        parent_tag = tag_hash(parent_slug_or_hash, tag_type)
-        child_tags = child_tag_ids.map { |id|
-          tag_hash(id, tag_type).merge(parent: parent_tag)
-        }
-        body = plural_response_base.merge(
-          "results" => child_tags.map { |s| tag_result(s, tag_type) }
-        )
-
-        url = "#{CONTENT_API_ENDPOINT}/tags.json?parent_id=#{CGI.escape(parent_tag[:slug])}&sort=#{sort_order}&type=#{tag_type}"
-        stub_request(:get, url).to_return(status: 200, body: body.to_json, headers: {})
-      end
-
-      def content_api_has_an_artefact(slug, body = artefact_for_slug(slug))
-        ArtefactStub.new(slug).with_response_body(body).stub
-      end
-
-      def content_api_has_unpublished_artefact(slug, edition, body = artefact_for_slug(slug))
-        ArtefactStub.new(slug)
-            .with_response_body(body)
-            .with_query_parameters(edition: edition)
-            .stub
-      end
-
-      def content_api_has_an_artefact_with_snac_code(slug, snac, body = artefact_for_slug(slug))
-        ArtefactStub.new(slug)
-            .with_response_body(body)
-            .with_query_parameters(snac: snac)
-            .stub
-      end
-
-      def content_api_does_not_have_an_artefact(slug)
-        body = {
-          "_response_info" => {
-            "status" => "not found"
-          }
-        }
-        ArtefactStub.new(slug)
-            .with_response_body(body)
-            .with_response_status(404)
-            .stub
-      end
-
-      def content_api_has_an_archived_artefact(slug)
-        body = {
-          "_response_info" => {
-            "status" => "gone",
-            "status_message" => "This item is no longer available"
-          }
-        }
-        ArtefactStub.new(slug)
-            .with_response_body(body)
-            .with_response_status(410)
-            .stub
-      end
-
-      # Stub requests, and then dynamically generate a response based on the slug in the request
-      def stub_content_api_default_artefact
-        stub_request(:get, %r{\A#{CONTENT_API_ENDPOINT}/[a-z0-9-]+\.json}).to_return { |request|
-          slug = request.uri.path.split('/').last.chomp('.json')
-          { body: artefact_for_slug(slug).to_json }
-        }
-      end
-
-      def artefact_for_slug(slug, options = {})
-        singular_response_base.merge(
-          "title" => titleize_slug(slug),
-          "format" => options.fetch(:format, "guide"),
-          "id" => "#{CONTENT_API_ENDPOINT}/#{CGI.escape(slug)}.json",
-          "web_url" => "http://frontend.test.gov.uk/#{slug}",
-          "details" => {
-            "need_ids" => ["100001"],
-            "business_proposition" => false, # To be removed and replaced with proposition tags
-            "format" => options.fetch(:format, "guide"),
-            "alternative_title" => "",
-            "overview" => "This is an overview",
-            "video_summary" => "",
-            "video_url" => "",
-            "parts" => [
-              {
-                "id" => "overview",
-                "order" => 1,
-                "title" => "Overview",
-                "body" => "<p>Some content</p>"
-              },
-              {
-                "id" => "#{slug}-part-2",
-                "order" => 2,
-                "title" => "How to make a nomination",
-                "body" => "<p>Some more content</p>"
-              }
-            ]
-          },
-          "tags" => [],
-          "related" => []
-        )
-      end
-
-      def artefact_for_slug_with_a_tag(tag_type, slug, tag_id)
-        artefact = artefact_for_slug(slug)
-        artefact["tags"] << tag_for_slug(tag_id, tag_type)
-        artefact
-      end
-
-      def artefact_for_slug_with_a_child_tag(tag_type, slug, child_tag_id)
-        artefact_for_slug_with_a_child_tags(tag_type, slug, [child_tag_id])
-      end
-
-      def artefact_for_slug_with_a_child_tags(tag_type, slug, child_tag_ids)
-        artefact = artefact_for_slug(slug)
-
-        child_tag_ids.each do |child_tag_id|
-          # for each "part" of the path, we want to reduce across the
-          # list and build up a tree of nested tags.
-          # This will turn "thing1/thing2" into:
-          #   Tag{ thing2, parent: Tag{ thing1 } }
-
-          tag_tree = nil
-          child_tag_id.split('/').inject(nil) do |parent_tag, child_tag|
-            child_tag = [parent_tag, child_tag].join('/') if parent_tag
-            next_level_tag = tag_for_slug(child_tag, tag_type)
-            tag_tree = if tag_tree
-              # Because tags are nested within one another, this makes
-              # the current part the top, and the rest we've seen the
-              # ancestors
-                         next_level_tag.merge("parent" => tag_tree)
-                       else
-                         next_level_tag
-                       end
-
-            # This becomes the parent tag in the next iteration of the block
-            child_tag
-          end
-          artefact["tags"] << tag_tree
-        end
-
-        artefact
-      end
-
-      def artefact_for_slug_with_related_artefacts(slug, related_artefact_slugs)
-        artefact = artefact_for_slug(slug)
-        artefact["related"] = related_artefact_slugs.map do |related_slug|
-          {
-            "title" => titleize_slug(related_slug),
-            "id" => "#{CONTENT_API_ENDPOINT}/#{CGI.escape(related_slug)}.json",
-            "web_url" => "https://www.test.gov.uk/#{related_slug}",
-            "details" => {}
-          }
-        end
-        artefact
-      end
-
-      def tag_for_slug(slug, tag_type, parent_slug = nil)
-        if parent_slug
-          parent = tag_for_slug(parent_slug, tag_type)
-        end
-
-        tag_result(slug: slug, type: tag_type, parent: parent)
-      end
-
-      # Construct a tag hash suitable for passing into tag_result
-      def tag_hash(slug_or_hash, tag_type = "section")
-        if slug_or_hash.is_a?(Hash)
-          slug_or_hash
-        else
-          { slug: slug_or_hash, type: tag_type }
-        end
-      end
-
-      def tag_result(slug_or_hash, tag_type = nil, options = {})
-        tag = tag_hash(slug_or_hash, tag_type)
-
-        parent = tag_result(tag[:parent]) if tag[:parent]
-        pluralized_tag_type = simple_tag_type_pluralizer(tag[:type])
-
-        {
-          "id" => "#{CONTENT_API_ENDPOINT}/tags/#{CGI.escape(pluralized_tag_type)}/#{CGI.escape(tag[:slug])}.json",
-          "slug" => tag[:slug],
-          "web_url" => "http://www.test.gov.uk/browse/#{tag[:slug]}",
-          "title" => tag[:title] || titleize_slug(tag[:slug].split("/").last),
-          "details" => {
-            "type" => tag[:type],
-            "description" => tag[:description] || "#{tag[:slug]} description",
-            "short_description" => tag[:short_description] || "#{tag[:slug]} short description"
-          },
-          "parent" => parent,
-          "content_with_tag" => {
-            "id" => "#{CONTENT_API_ENDPOINT}/with_tag.json?tag=#{CGI.escape(tag[:slug])}",
-            "web_url" => "http://www.test.gov.uk/browse/#{tag[:slug]}"
-          },
-          "state" => options[:state]
-        }
-      end
-
-      # This is a nasty hack to get around the pluralized slugs in tag paths
-      # without having to require ActiveSupport
-      #
-      def simple_tag_type_pluralizer(s)
-        case s
-        when /o\Z/ then s.sub(/o\Z/, "es")
-        when /y\Z/ then s.sub(/y\Z/, "ies")
-        when /ss\Z/ then s.sub(/ss\Z/, "sses")
-        else
-          "#{s}s"
-        end
-      end
-
-      def content_api_has_artefacts_for_need_id(need_id, artefacts)
-        url = "#{CONTENT_API_ENDPOINT}/for_need/#{CGI.escape(need_id.to_s)}.json"
-        body = plural_response_base.merge(
-          'results' => artefacts
-        )
-
-        stub_request(:get, url).to_return(status: 200, body: body.to_json, headers: [])
-      end
-    end
-  end
-end
-
-# This has to be after the definition of TestHelpers::ContentApi, otherwise, this doesn't pick up
-# the include of TestHelpers::CommonResponses
-require_relative 'content_api/artefact_stub'

data/lib/gds_api/test_helpers/content_api/artefact_stub.rb

@@ -1,58 +0,0 @@
-require 'webmock'
-
-module GdsApi
-  module TestHelpers
-    module ContentApi
-      class ArtefactStub
-        include WebMock::API
-        # This is ugly, but the nicest way we found to get access to artefact_for_slug
-        include GdsApi::TestHelpers::ContentApi
-
-        attr_accessor :slug, :query_parameters, :response_body, :response_status
-
-        def initialize(slug)
-          @slug = slug
-          @query_parameters = {}
-          @response_body = artefact_for_slug(slug)
-          @response_status = 200
-        end
-
-        def with_query_parameters(hash)
-          @query_parameters = hash
-          self
-        end
-
-        def with_response_body(response_body)
-          @response_body = response_body
-          self
-        end
-
-        def with_response_status(response_status)
-          @response_status = response_status
-          self
-        end
-
-        # Nothing is stubbed until this is called
-        def stub
-          stub_request(:get, url_without_query)
-              .with(query: hash_including(comparable_query_params))
-              .to_return(status: @response_status, body: @response_body.to_json)
-        end
-
-      private
-
-        def url_without_query
-          "#{CONTENT_API_ENDPOINT}/#{CGI.escape(slug)}.json"
-        end
-
-        # Ensure that all keys and values are strings
-        # because Webmock doesn't handle symbols
-        def comparable_query_params
-          @query_parameters.each_with_object({}) do |(k, v), hash|
-            hash[k.to_s] = v.nil? ? v : v.to_s
-          end
-        end
-      end
-    end
-  end
-end