gds-api-adapters 70.0.0 → 71.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 632391e17f65b54797ea177945c0993fc71545d61a10975b244cf45355723ca1
-  data.tar.gz: dc7b387e7d2038c54541d4dd5382a75d316bbe383870326e89c6c31e8fdbb229
+  metadata.gz: d1bcd6f2192952444f80e49762cc4d1e2820c767162d194de9ce6c0f1b78ad2c
+  data.tar.gz: cc96d6dc6f18b3ec2a58187977147b8be0bf6025e7a47c4b55671f2ab900c78f
 SHA512:
-  metadata.gz: e1a99f505078d1b27dba69a7b53b1945fdc83c2eb25fb0a6627090d6b77b67b43f324f8ff1ae76c447608e0265749083b78f74d28ec5c7703be4600aebf15174
-  data.tar.gz: a02640e69fb8a4d0292bdd97dee1061c5c498c5412812d74b40733bd7e10a06077631b93f74e8687b763362e1b4776221e60e201d287cbccf3b6d6d1868795c4
+  metadata.gz: 2b0911632959b5c61c22ca3c5f208bd69d8cd6db5984fe83c4912251d38f1e895f8a90eda372de721a9f85a59af4931517eb468c3a23d554d9d3a9e4ecd24734
+  data.tar.gz: 1ed0f2a61ed3833a05283684a443ae148324ae22e92daa49e14982af4e908ea5e4f96cda2f74ad20bedae96fdad3d4641fee09c01b958fd63e53190e319b7357

data/lib/gds_api/account_api.rb

@@ -12,10 +12,17 @@ class GdsApi::AccountApi < GdsApi::Base
   #
   # @param [String, nil] redirect_path path on GOV.UK to send the user to after authentication
   # @param [String, nil] state_id identifier originally returned by #create_registration_state
+  # @param [String, nil] level_of_authentication either "level1" (require MFA) or "level0" (do not require MFA)
   #
   # @return [Hash] An authentication URL and the OAuth state parameter (for CSRF protection)
-  def get_sign_in_url(redirect_path: nil, state_id: nil)
-    querystring = nested_query_string({ redirect_path: redirect_path, state_id: state_id }.compact)
+  def get_sign_in_url(redirect_path: nil, state_id: nil, level_of_authentication: nil)
+    querystring = nested_query_string(
+      {
+        redirect_path: redirect_path,
+        state_id: state_id,
+        level_of_authentication: level_of_authentication,
+      }.compact,
+    )
     get_json("#{endpoint}/api/oauth2/sign-in?#{querystring}")
   end
 
@@ -38,6 +45,26 @@ class GdsApi::AccountApi < GdsApi::Base
     post_json("#{endpoint}/api/oauth2/state", attributes: attributes)
   end
 
+  # Get all the information about a user needed to render the account home page
+  #
+  # @param [String] govuk_account_session Value of the session header
+  #
+  # @return [Hash] Information about the user and the services they've used, and a new session header
+  def get_user(govuk_account_session:)
+    get_json("#{endpoint}/api/user", auth_headers(govuk_account_session))
+  end
+
+  # Update the user record with privileged information from the auth service.  Only the auth service will call this.
+  #
+  # @param [String] subject_identifier The identifier of the user, shared between the auth service and GOV.UK.
+  # @param [String, nil] email The new email address
+  # @param [Boolean, nil] email_verified Whether the new email address is verified
+  #
+  # @return [Hash] The user's subject identifier and email attributes
+  def update_user_by_subject_identifier(subject_identifier:, email: nil, email_verified: nil)
+    patch_json("#{endpoint}/api/oidc-users/#{subject_identifier}", { email: email, email_verified: email_verified }.compact)
+  end
+
   # Check if a user has an email subscription for the Transition Checker
   #
   # @param [String] govuk_account_session Value of the session header
@@ -75,7 +102,58 @@ class GdsApi::AccountApi < GdsApi::Base
   #
   # @return [Hash] A new session header
   def set_attributes(attributes:, govuk_account_session:)
-    patch_json("#{endpoint}/api/attributes", { attributes: attributes.transform_values(&:to_json) }, auth_headers(govuk_account_session))
+    patch_json("#{endpoint}/api/attributes", { attributes: attributes }, auth_headers(govuk_account_session))
+  end
+
+  # Look up the names of a user's attributes
+  #
+  # @param [String] attributes Names of the attributes to check
+  # @param [String] govuk_account_session Value of the session header
+  #
+  # @return [Hash] The attribute names (if present), and a new session header
+  def get_attributes_names(attributes:, govuk_account_session:)
+    querystring = nested_query_string({ attributes: attributes }.compact)
+    get_json("#{endpoint}/api/attributes/names?#{querystring}", auth_headers(govuk_account_session))
+  end
+
+  # Look up all pages saved by a user in their Account
+  #
+  # @param [String] govuk_account_session Value of the session header
+  #
+  # @return [Hash] containing :saved_pages, an array of single saved page hashes  def get_saved_pages(govuk_account_session:)
+  def get_saved_pages(govuk_account_session:)
+    get_json("#{endpoint}/api/saved-pages", auth_headers(govuk_account_session))
+  end
+
+  # Return a single page by unique URL
+  #
+  # @param [String] the path of a page to check
+  # @param [String] govuk_account_session Value of the session header
+  #
+  # @return [Hash] containing :saved_page, a hash of a single saved page value
+  def get_saved_page(page_path:, govuk_account_session:)
+    get_json("#{endpoint}/api/saved-pages/#{CGI.escape(page_path)}", auth_headers(govuk_account_session))
+  end
+
+  # Upsert a single saved page entry in a users account
+  #
+  # @param [String] the path of a page to check
+  # @param [String] govuk_account_session Value of the session header
+  #
+  # @return [Hash] A single saved page value (if sucessful)
+  def save_page(page_path:, govuk_account_session:)
+    put_json("#{endpoint}/api/saved-pages/#{CGI.escape(page_path)}", {}, auth_headers(govuk_account_session))
+  end
+
+  # Delete a single saved page entry from a users account
+  #
+  # @param [String] the path of a page to check
+  # @param [String] govuk_account_session Value of the session header
+  #
+  # @return [GdsApi::Response] A status code of 204 indicates the saved page has been successfully deleted.
+  #                            A status code of 404 indicates there is no saved page with this path.
+  def delete_saved_page(page_path:, govuk_account_session:)
+    delete_json("#{endpoint}/api/saved-pages/#{CGI.escape(page_path)}", {}, auth_headers(govuk_account_session))
   end
 
 private

data/lib/gds_api/exceptions.rb

@@ -23,12 +23,13 @@ module GdsApi
 
   # Superclass for all 4XX and 5XX errors
   class HTTPErrorResponse < BaseError
-    attr_accessor :code, :error_details
+    attr_accessor :code, :error_details, :http_body
 
-    def initialize(code, message = nil, error_details = nil)
+    def initialize(code, message = nil, error_details = nil, http_body = nil)
       super(message)
       @code = code
       @error_details = error_details
+      @http_body = http_body
     end
   end
 
@@ -72,7 +73,7 @@ module GdsApi
     def build_specific_http_error(error, url, details = nil)
       message = "URL: #{url}\nResponse body:\n#{error.http_body}"
       code = error.http_code
-      error_class_for_code(code).new(code, message, details)
+      error_class_for_code(code).new(code, message, details, error.http_body)
     end
 
     def error_class_for_code(code)

data/lib/gds_api/json_client.rb

@@ -180,10 +180,10 @@ module GdsApi
       raise GdsApi::EndpointNotFound, "Could not connect to #{url}"
     rescue RestClient::Exceptions::Timeout => e
       logger.error loggable.merge(status: "timeout", error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
-      raise GdsApi::TimedOutException
+      raise GdsApi::TimedOutException, e.message
     rescue URI::InvalidURIError => e
       logger.error loggable.merge(status: "invalid_uri", error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
-      raise GdsApi::InvalidUrl
+      raise GdsApi::InvalidUrl, e.message
     rescue RestClient::Exception => e
       # Log the error here, since we have access to loggable, but raise the
       # exception up to the calling method to deal with
@@ -192,10 +192,10 @@ module GdsApi
       raise
     rescue Errno::ECONNRESET => e
       logger.error loggable.merge(status: "connection_reset", error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
-      raise GdsApi::TimedOutException
+      raise GdsApi::TimedOutException, e.message
     rescue SocketError => e
       logger.error loggable.merge(status: "socket_error", error_message: e.message, error_class: e.class.name, end_time: Time.now.to_f).to_json
-      raise GdsApi::SocketErrorException
+      raise GdsApi::SocketErrorException, e.message
     end
   end
 end

data/lib/gds_api/link_checker_api.rb

@@ -89,37 +89,6 @@ class GdsApi::LinkCheckerApi < GdsApi::Base
     )
   end
 
-  # Update or create a set of links to be monitored for a resource.
-  #
-  # Makes a +POST+ request to the link checker api to create a resource monitor.
-  #
-  # @param links [Array] A list of URIs to monitor.
-  # @param reference [String] A unique id for the resource being monitored
-  # @param app [String] The name of the service the call originated e.g. 'whitehall'
-  # @return [MonitorReport] A +SimpleDelegator+ of the +GdsApi::Response+ which
-  #   responds to:
-  #     :id            the ID of the created resource monitor
-  #
-  # @raise [HTTPErrorResponse] if the request returns an error
-
-  def upsert_resource_monitor(links, app, reference)
-    payload = {
-      links: links,
-      app: app,
-      reference: reference,
-    }
-
-    response = post_json("#{endpoint}/monitor", payload)
-
-    MonitorReport.new(response.to_hash)
-  end
-
-  class MonitorReport < SimpleDelegator
-    def id
-      self["id"]
-    end
-  end
-
   class LinkReport < SimpleDelegator
     def uri
       self["uri"]

data/lib/gds_api/test_helpers/account_api.rb

@@ -5,8 +5,8 @@ module GdsApi
     module AccountApi
       ACCOUNT_API_ENDPOINT = Plek.find("account-api")
 
-      def stub_account_api_get_sign_in_url(redirect_path: nil, state_id: nil, auth_uri: "http://auth/provider", state: "state")
-        querystring = Rack::Utils.build_nested_query({ redirect_path: redirect_path, state_id: state_id }.compact)
+      def stub_account_api_get_sign_in_url(redirect_path: nil, state_id: nil, level_of_authentication: nil, auth_uri: "http://auth/provider", state: "state")
+        querystring = Rack::Utils.build_nested_query({ redirect_path: redirect_path, state_id: state_id, level_of_authentication: level_of_authentication }.compact)
         stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/oauth2/sign-in?#{querystring}")
           .to_return(
             status: 200,
@@ -38,63 +38,356 @@ module GdsApi
           )
       end
 
-      def stub_account_api_has_email_subscription(govuk_account_session: nil, new_govuk_account_session: nil)
-        if govuk_account_session
-          stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/transition-checker-email-subscription")
-            .with(headers: { GdsApi::AccountApi::AUTH_HEADER_NAME => govuk_account_session })
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session, has_subscription: true }.compact.to_json)
-        else
-          stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/transition-checker-email-subscription")
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session, has_subscription: true }.compact.to_json)
-        end
+      def stub_account_api_user_info(level_of_authentication: "level0", email: "email@example.com", email_verified: true, services: {}, **options)
+        stub_account_api_request(
+          :get,
+          "/api/user",
+          response_body: {
+            level_of_authentication: level_of_authentication,
+            email: email,
+            email_verified: email_verified,
+            services: services,
+          },
+          **options,
+        )
       end
 
-      def stub_account_api_does_not_have_email_subscription(govuk_account_session: nil, new_govuk_account_session: nil)
-        if govuk_account_session
-          stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/transition-checker-email-subscription")
-            .with(headers: { GdsApi::AccountApi::AUTH_HEADER_NAME => govuk_account_session })
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session, has_subscription: false }.compact.to_json)
-        else
-          stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/transition-checker-email-subscription")
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session, has_subscription: false }.compact.to_json)
-        end
+      def stub_account_api_user_info_service_state(service:, service_state: "yes", **options)
+        stub_account_api_user_info(
+          **options.merge(
+            services: options.fetch(:services, {}).merge(service => service_state),
+          ),
+        )
       end
 
-      def stub_account_api_set_email_subscription(govuk_account_session: nil, slug: "slug", new_govuk_account_session: nil)
-        if govuk_account_session
-          stub_request(:post, "#{ACCOUNT_API_ENDPOINT}/api/transition-checker-email-subscription")
-            .with(body: hash_including({ slug: slug }.compact), headers: { GdsApi::AccountApi::AUTH_HEADER_NAME => govuk_account_session })
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session }.compact.to_json)
-        else
-          stub_request(:post, "#{ACCOUNT_API_ENDPOINT}/api/transition-checker-email-subscription")
-            .with(body: hash_including({ slug: slug }.compact))
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session }.compact.to_json)
-        end
+      def stub_account_api_unauthorized_user_info(**options)
+        stub_account_api_request(
+          :get,
+          "/api/user",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def stub_update_user_by_subject_identifier(subject_identifier:, email: nil, email_verified: nil, old_email: nil, old_email_verified: nil)
+        stub_account_api_request(
+          :patch,
+          "/api/oidc-users/#{subject_identifier}",
+          with: { body: hash_including({ email: email, email_verified: email_verified }.compact) },
+          response_body: {
+            sub: subject_identifier,
+            email: email || old_email,
+            email_verified: email_verified || old_email_verified,
+          },
+        )
+      end
+
+      def stub_account_api_has_email_subscription(**options)
+        stub_account_api_request(
+          :get,
+          "/api/transition-checker-email-subscription",
+          response_body: { has_subscription: true },
+          **options,
+        )
+      end
+
+      def stub_account_api_does_not_have_email_subscription(**options)
+        stub_account_api_request(
+          :get,
+          "/api/transition-checker-email-subscription",
+          response_body: { has_subscription: false },
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_get_email_subscription(**options)
+        stub_account_api_request(
+          :get,
+          "/api/transition-checker-email-subscription",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def stub_account_api_forbidden_get_email_subscription(needed_level_of_authentication: "level1", **options)
+        stub_account_api_request(
+          :get,
+          "/api/transition-checker-email-subscription",
+          response_status: 403,
+          response_body: { needed_level_of_authentication: needed_level_of_authentication },
+          **options,
+        )
+      end
+
+      def stub_account_api_set_email_subscription(slug: nil, **options)
+        stub_account_api_request(
+          :post,
+          "/api/transition-checker-email-subscription",
+          with: { body: hash_including({ slug: slug }.compact) },
+          **options,
+        )
       end
 
-      def stub_account_api_has_attributes(govuk_account_session: nil, attributes: [], values: {}, new_govuk_account_session: nil)
+      def stub_account_api_unauthorized_set_email_subscription(slug: nil, **options)
+        stub_account_api_request(
+          :post,
+          "/api/transition-checker-email-subscription",
+          with: { body: hash_including({ slug: slug }.compact) },
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def stub_account_api_forbidden_set_email_subscription(slug: nil, needed_level_of_authentication: "level1", **options)
+        stub_account_api_request(
+          :post,
+          "/api/transition-checker-email-subscription",
+          with: { body: hash_including({ slug: slug }.compact) },
+          response_status: 403,
+          response_body: { needed_level_of_authentication: needed_level_of_authentication },
+          **options,
+        )
+      end
+
+      def stub_account_api_has_attributes(attributes: [], values: {}, **options)
         querystring = Rack::Utils.build_nested_query({ attributes: attributes }.compact)
-        if govuk_account_session
-          stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/attributes?#{querystring}")
-            .with(headers: { GdsApi::AccountApi::AUTH_HEADER_NAME => govuk_account_session })
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session, values: values }.compact.to_json)
-        else
-          stub_request(:get, "#{ACCOUNT_API_ENDPOINT}/api/attributes?#{querystring}")
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session, values: values }.compact.to_json)
-        end
+        stub_account_api_request(
+          :get,
+          "/api/attributes?#{querystring}",
+          response_body: { values: values },
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_has_attributes(attributes: [], **options)
+        querystring = Rack::Utils.build_nested_query({ attributes: attributes }.compact)
+        stub_account_api_request(
+          :get,
+          "/api/attributes?#{querystring}",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def stub_account_api_forbidden_has_attributes(attributes: [], needed_level_of_authentication: "level1", **options)
+        querystring = Rack::Utils.build_nested_query({ attributes: attributes }.compact)
+        stub_account_api_request(
+          :get,
+          "/api/attributes?#{querystring}",
+          response_status: 403,
+          response_body: { needed_level_of_authentication: needed_level_of_authentication },
+          **options,
+        )
+      end
+
+      def stub_account_api_set_attributes(attributes: nil, **options)
+        stub_account_api_request(
+          :patch,
+          "/api/attributes",
+          with: { body: hash_including({ attributes: attributes }.compact) },
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_set_attributes(attributes: nil, **options)
+        stub_account_api_request(
+          :patch,
+          "/api/attributes",
+          with: { body: hash_including({ attributes: attributes }.compact) },
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def stub_account_api_forbidden_set_attributes(attributes: nil, needed_level_of_authentication: "level1", **options)
+        stub_account_api_request(
+          :patch,
+          "/api/attributes",
+          with: { body: hash_including({ attributes: attributes }.compact) },
+          response_status: 403,
+          response_body: { needed_level_of_authentication: needed_level_of_authentication },
+          **options,
+        )
       end
 
-      def stub_account_api_set_attributes(govuk_account_session: nil, attributes: nil, new_govuk_account_session: nil)
-        if govuk_account_session
-          stub_request(:patch, "#{ACCOUNT_API_ENDPOINT}/api/attributes")
-            .with(body: hash_including({ attributes: attributes&.transform_values(&:to_json) }.compact), headers: { GdsApi::AccountApi::AUTH_HEADER_NAME => govuk_account_session })
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session }.compact.to_json)
+      def stub_account_api_get_attributes_names(attributes: [], **options)
+        querystring = Rack::Utils.build_nested_query({ attributes: attributes }.compact)
+        stub_account_api_request(
+          :get,
+          "/api/attributes/names?#{querystring}",
+          response_body: { values: attributes },
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_get_attributes_names(attributes: [], **options)
+        querystring = Rack::Utils.build_nested_query({ attributes: attributes }.compact)
+        stub_account_api_request(
+          :get,
+          "/api/attributes/names?#{querystring}",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def stub_account_api_forbidden_get_attributes_names(attributes: [], needed_level_of_authentication: "level1", **options)
+        querystring = Rack::Utils.build_nested_query({ attributes: attributes }.compact)
+        stub_account_api_request(
+          :get,
+          "/api/attributes/names?#{querystring}",
+          response_status: 403,
+          response_body: { needed_level_of_authentication: needed_level_of_authentication },
+          **options,
+        )
+      end
+
+      def stub_account_api_request(method, path, with: {}, response_status: 200, response_body: {}, govuk_account_session: nil, new_govuk_account_session: nil)
+        with.merge!(headers: { GdsApi::AccountApi::AUTH_HEADER_NAME => govuk_account_session }) if govuk_account_session
+        new_govuk_account_session = nil if response_status >= 400
+        to_return = { status: response_status, body: response_body.merge(govuk_account_session: new_govuk_account_session).compact.to_json }
+        if with.empty?
+          stub_request(method, "#{ACCOUNT_API_ENDPOINT}#{path}").to_return(**to_return)
         else
-          stub_request(:patch, "#{ACCOUNT_API_ENDPOINT}/api/attributes")
-            .with(body: hash_including({ attributes: attributes&.transform_values(&:to_json) }.compact))
-            .to_return(status: 200, body: { govuk_account_session: new_govuk_account_session }.compact.to_json)
+          stub_request(method, "#{ACCOUNT_API_ENDPOINT}#{path}").with(**with).to_return(**to_return)
         end
       end
+
+      ######################
+      # GET /api/saved-pages
+      ######################
+      def stub_account_api_returning_saved_pages(saved_pages: [], **options)
+        stub_account_api_request(
+          :get,
+          "/api/saved-pages",
+          response_body: { saved_pages: saved_pages },
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_get_saved_pages(**options)
+        stub_account_api_request(
+          :get,
+          "/api/saved-pages",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      #################################
+      # GET /api/saved_pages/:page_path
+      #################################
+      def stub_account_api_get_saved_page(page_path:, content_id: "46163ed2-1777-4ee6-bdd4-6a2007e49d8f", title: "Ministry of Magic", **options)
+        stub_account_api_request(
+          :get,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_body: {
+            saved_page: {
+              page_path: page_path,
+              content_id: content_id,
+              title: title,
+            },
+          },
+          **options,
+        )
+      end
+
+      def stub_account_api_does_not_have_saved_page(page_path:, **options)
+        stub_account_api_request(
+          :get,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 404,
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_get_saved_page(page_path:, **options)
+        stub_account_api_request(
+          :get,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      #################################
+      # PUT /api/saved-pages/:page_path
+      #################################
+      def stub_account_api_save_page(page_path:, content_id: "c840bfa2-011a-42cc-ac7a-a6da990aff0b", title: "Ministry of Magic", **options)
+        stub_account_api_request(
+          :put,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_body: {
+            saved_page: {
+              page_path: page_path,
+              content_id: content_id,
+              title: title,
+            },
+          },
+          **options,
+        )
+      end
+
+      def stub_account_api_save_page_already_exists(page_path:, **options)
+        stub_account_api_save_page(page_path: page_path, **options)
+      end
+
+      def stub_account_api_save_page_cannot_save_page(page_path:, **options)
+        stub_account_api_request(
+          :put,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 422,
+          response_body: cannot_save_page_problem_detail({ page_path: page_path }),
+          **options,
+        )
+      end
+
+      def stub_account_api_unauthorized_save_page(page_path:, **options)
+        stub_account_api_request(
+          :put,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 401,
+          **options,
+        )
+      end
+
+      def cannot_save_page_problem_detail(option = {})
+        {
+          title: "Cannot save page",
+          detail: "Cannot save page with path #{option['page_path']}, check it is not blank, and is a well formatted url path.",
+          type: "https://github.com/alphagov/account-api/blob/main/docs/api.md#cannot-save-page",
+          **option,
+        }
+      end
+
+      ####################################
+      # DELETE /api/saved-pages/:page_path
+      ####################################
+      def stub_account_api_delete_saved_page(page_path:, **options)
+        stub_account_api_request(
+          :delete,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 204,
+          **options,
+        )
+      end
+
+      def stub_account_api_delete_saved_page_does_not_exist(page_path:, **options)
+        stub_account_api_request(
+          :delete,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 404,
+          **options,
+        )
+      end
+
+      def stub_account_api_delete_saved_page_unauthorised(page_path:, **options)
+        stub_account_api_request(
+          :delete,
+          "/api/saved-pages/#{CGI.escape(page_path)}",
+          response_status: 401,
+          **options,
+        )
+      end
     end
   end
 end

data/lib/gds_api/test_helpers/link_checker_api.rb

@@ -72,23 +72,6 @@ module GdsApi
             headers: { "Content-Type" => "application/json" },
           )
       end
-
-      def stub_link_checker_api_upsert_resource_monitor(app:, reference:, links:)
-        response_body = { id: 1 }.to_json
-
-        request_body = {
-          links: links,
-          app: app,
-          reference: reference,
-        }.to_json
-
-        stub_request(:post, "#{LINK_CHECKER_API_ENDPOINT}/monitor")
-          .with(body: request_body)
-          .to_return(
-            body: response_body,
-            headers: { "Content-Type" => "application/json" },
-          )
-      end
     end
   end
 end

data/lib/gds_api/version.rb

@@ -1,3 +1,3 @@
 module GdsApi
-  VERSION = "70.0.0".freeze
+  VERSION = "71.4.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gds-api-adapters
 version: !ruby/object:Gem::Version
-  version: 70.0.0
+  version: 71.4.0
 platform: ruby
 authors:
 - GOV.UK Dev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-15 00:00:00.000000000 Z
+date: 2021-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -389,8 +389,6 @@ files:
 - lib/gds_api/maslow.rb
 - lib/gds_api/middleware/govuk_header_sniffer.rb
 - lib/gds_api/organisations.rb
-- lib/gds_api/performance_platform/data_in.rb
-- lib/gds_api/performance_platform/data_out.rb
 - lib/gds_api/publishing_api.rb
 - lib/gds_api/publishing_api/special_route_publisher.rb
 - lib/gds_api/railtie.rb
@@ -413,8 +411,6 @@ files:
 - lib/gds_api/test_helpers/local_links_manager.rb
 - lib/gds_api/test_helpers/mapit.rb
 - lib/gds_api/test_helpers/organisations.rb
-- lib/gds_api/test_helpers/performance_platform/data_in.rb
-- lib/gds_api/test_helpers/performance_platform/data_out.rb
 - lib/gds_api/test_helpers/publishing_api.rb
 - lib/gds_api/test_helpers/router.rb
 - lib/gds_api/test_helpers/search.rb
@@ -449,7 +445,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Adapters to work with GDS APIs

data/lib/gds_api/performance_platform/data_in.rb

@@ -1,27 +0,0 @@
-require_relative "../base"
-
-module GdsApi
-  class PerformancePlatformDatasetNotConfigured < BaseError; end
-
-  module PerformancePlatform
-    class DataIn < GdsApi::Base
-      def submit_service_feedback_day_aggregate(slug, request_details)
-        post_json("#{endpoint}/data/#{slug}/customer-satisfaction", request_details)
-      rescue GdsApi::HTTPNotFound
-        raise PerformancePlatformDatasetNotConfigured, "Dataset for slug [#{slug}] not set up"
-      end
-
-      def corporate_content_problem_report_count(entries)
-        post_json("#{endpoint}/data/gov-uk-content/feedback-count", entries)
-      end
-
-      def corporate_content_urls_with_the_most_problem_reports(entries)
-        post_json("#{endpoint}/data/gov-uk-content/top-urls", entries)
-      end
-
-      def submit_problem_report_daily_totals(entries)
-        post_json("#{endpoint}/data/govuk-info/page-contacts", entries)
-      end
-    end
-  end
-end

data/lib/gds_api/performance_platform/data_out.rb

@@ -1,131 +0,0 @@
-require_relative "../base"
-
-module GdsApi
-  module PerformancePlatform
-    class DataOut < GdsApi::Base
-      # Fetch all service feedback from the performance platform for a given transaction
-      # page slug.
-      #
-      # Makes a +GET+ request.
-      #
-      # The results are ordered date ascending.
-      #
-      # @param transaction_page_slug [String] The slug for which service feedback is
-      # needed.
-      #
-      # # @example
-      #
-      #  performance_platform_data_out.service_feedback('register-to-vote')
-      #
-      #  #=> {
-      #      "data": [
-      #   {
-      #     "_day_start_at": "2014-06-10T00:00:00+00:00",
-      #     "_hour_start_at": "2014-06-10T00:00:00+00:00",
-      #     "_id": "20140610_register-to-vote",
-      #     "_month_start_at": "2014-06-01T00:00:00+00:00",
-      #     "_quarter_start_at": "2014-04-01T00:00:00+00:00",
-      #     "_timestamp": "2014-06-10T00:00:00+00:00",
-      #     "_updated_at": "2014-06-11T00:30:50.901000+00:00",
-      #     "_week_start_at": "2014-06-09T00:00:00+00:00",
-      #     "comments": 217,
-      #     "period": "day",
-      #     "rating_1": 4,
-      #     "rating_2": 6,
-      #     "rating_3": 7,
-      #     "rating_4": 74,
-      #     "rating_5": 574,
-      #     "slug": "register-to-vote",
-      #     "total": 665
-      #   },
-      #   ...
-      #  }
-      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: "search-terms",
-          group_by: "searchKeyword",
-          collect: "searchUniques:sum",
-        }
-        statistics(options)
-      end
-
-      def searches(slug, is_multipart)
-        options = {
-          slug: slug,
-          transaction: "search-terms",
-          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) # rubocop:disable Style/OptionalBooleanParameter
-        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_in.rb

@@ -1,45 +0,0 @@
-module GdsApi
-  module TestHelpers
-    module PerformancePlatform
-      module DataIn
-        PP_DATA_IN_ENDPOINT = "http://www.performance.dev.gov.uk".freeze
-
-        def stub_service_feedback_day_aggregate_submission(slug, request_body = nil)
-          post_stub = stub_http_request(:post, "#{PP_DATA_IN_ENDPOINT}/data/#{slug}/customer-satisfaction")
-          post_stub.with(body: request_body) unless request_body.nil?
-          post_stub.to_return(status: 200)
-        end
-
-        def stub_corporate_content_problem_report_count_submission(submissions = nil)
-          post_stub = stub_http_request(:post, "#{PP_DATA_IN_ENDPOINT}/data/gov-uk-content/feedback-count")
-          post_stub.with(body: submissions.to_json) unless submissions.nil?
-          post_stub.to_return(status: 200)
-        end
-
-        def stub_corporate_content_urls_with_the_most_problem_reports_submission(submissions = nil)
-          post_stub = stub_http_request(:post, "#{PP_DATA_IN_ENDPOINT}/data/gov-uk-content/top-urls")
-          post_stub.with(body: submissions.to_json) unless submissions.nil?
-          post_stub.to_return(status: 200)
-        end
-
-        def stub_problem_report_daily_totals_submission(submissions = nil)
-          post_stub = stub_http_request(:post, "#{PP_DATA_IN_ENDPOINT}/data/govuk-info/page-contacts")
-          post_stub.with(body: submissions.to_json) unless submissions.nil?
-          post_stub.to_return(status: 200)
-        end
-
-        def stub_service_feedback_bucket_unavailable_for(slug)
-          stub_request(:post, "#{PP_DATA_IN_ENDPOINT}/data/#{slug}/customer-satisfaction").to_return(status: 404)
-        end
-
-        def stub_pp_isnt_available
-          stub_request(:post, /#{PP_DATA_IN_ENDPOINT}\/.*/).to_return(status: 503)
-        end
-
-        def stub_pp_dataset_unavailable
-          stub_request(:any, /#{PP_DATA_IN_ENDPOINT}/).to_return(status: 404)
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-module GdsApi
-  module TestHelpers
-    module PerformancePlatform
-      module DataOut
-        PP_DATA_OUT_ENDPOINT = "https://www.performance.service.gov.uk".freeze
-
-        def stub_service_feedback(slug, response_body = {})
-          stub_http_request(:get, "#{PP_DATA_OUT_ENDPOINT}/data/#{slug}/customer-satisfaction")
-            .to_return(status: 200, body: response_body.to_json)
-        end
-
-        def stub_data_set_not_available(slug)
-          stub_http_request(:get, "#{PP_DATA_OUT_ENDPOINT}/data/#{slug}/customer-satisfaction")
-            .to_return(status: 404)
-        end
-
-        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: "search-terms",
-            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: "search-terms",
-            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/search-terms")
-              .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
-end