gds-api-adapters 5.5.0 → 6.0.0

data/lib/gds_api/base.rb

@@ -2,6 +2,7 @@ require_relative 'json_client'
 require 'cgi'
 require 'null_logger'
 require 'plek'
+require_relative 'list_response'
 
 class GdsApi::Base
   class InvalidAPIURL < StandardError
@@ -21,7 +22,8 @@ class GdsApi::Base
                           :post_json, :post_json!,
                           :put_json, :put_json!,
                           :delete_json!,
-                          :get_raw, :post_multipart
+                          :get_raw, :get_raw!,
+                          :post_multipart
 
   attr_reader :options
 
@@ -50,6 +52,12 @@ class GdsApi::Base
     base = "#{base_url}/#{slug}.json#{query_string(options)}"
   end
 
+  def get_list!(url)
+    get_json!(url) do |r|
+      GdsApi::ListResponse.new(r, self)
+    end
+  end
+
 private
   attr_accessor :endpoint
 

data/lib/gds_api/content_api.rb

@@ -1,7 +1,6 @@
 require_relative 'base'
 require_relative 'exceptions'
-require 'gds_api/content_api/response'
-require 'gds_api/content_api/list_response'
+require_relative 'list_response'
 
 class GdsApi::ContentApi < GdsApi::Base
   include GdsApi::ExceptionHandling
@@ -95,26 +94,26 @@ class GdsApi::ContentApi < GdsApi::Base
 
   def get_list!(url)
     get_json!(url) { |r|
-      ListResponse.new(r, self, web_urls_relative_to: @web_urls_relative_to)
+      GdsApi::ListResponse.new(r, self, web_urls_relative_to: @web_urls_relative_to)
     }
   end
 
   def get_list(url)
     get_json(url) { |r|
-      ListResponse.new(r, self, web_urls_relative_to: @web_urls_relative_to)
+      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::ContentApi::Response.new(r, web_urls_relative_to: @web_urls_relative_to)
+      GdsApi::Response.new(r, web_urls_relative_to: @web_urls_relative_to)
     }
     super(url, &create_response)
   end
 
   def get_json!(url, &create_response)
     create_response = create_response || Proc.new { |r|
-      GdsApi::ContentApi::Response.new(r, web_urls_relative_to: @web_urls_relative_to)
+      GdsApi::Response.new(r, web_urls_relative_to: @web_urls_relative_to)
     }
     super(url, &create_response)
   end

data/lib/gds_api/helpers.rb

@@ -4,6 +4,7 @@ require 'gds_api/panopticon'
 require 'gds_api/content_api'
 require 'gds_api/licence_application'
 require 'gds_api/asset_manager'
+require 'gds_api/worldwide'
 
 module GdsApi
   module Helpers
@@ -35,6 +36,10 @@ module GdsApi
       Object::const_defined?(:PANOPTICON_API_CREDENTIALS) ? PANOPTICON_API_CREDENTIALS : {}
     end
 
+    def worldwide_api(options = {})
+      @worldwide_api ||= GdsApi::Worldwide.new(Plek.current.find("whitehall-admin"), options)
+    end
+
     def self.included(klass)
       if klass.respond_to?(:helper_method)
         klass.helper_method :publisher_api, :panopticon_api, :imminence_api, :content_api, :licence_application_api

data/lib/gds_api/json_client.rb

@@ -1,6 +1,7 @@
 require_relative 'response'
 require_relative 'exceptions'
 require_relative 'version'
+require_relative 'null_cache'
 require 'lrucache'
 require 'rest-client'
 
@@ -20,10 +21,19 @@ module GdsApi
     attr_accessor :logger, :options, :cache
 
     def initialize(options = {})
+      if options[:disable_timeout] or options[:timeout].to_i < 0
+        raise "It is no longer possible to disable the timeout."
+      end
+
       @logger = options[:logger] || GdsApi::Base.logger
-      cache_size = options[:cache_size] || DEFAULT_CACHE_SIZE
-      cache_ttl = options[:cache_ttl] || DEFAULT_CACHE_TTL
-      @cache = JsonClient.cache(cache_size, cache_ttl)
+
+      if options[:disable_cache]
+        @cache = NullCache.new
+      else
+        cache_size = options[:cache_size] || DEFAULT_CACHE_SIZE
+        cache_ttl = options[:cache_ttl] || DEFAULT_CACHE_TTL
+        @cache = JsonClient.cache(cache_size, cache_ttl)
+      end
       @options = options
     end
 
@@ -33,12 +43,16 @@ module GdsApi
         'User-Agent' => "GDS Api Client v. #{GdsApi::VERSION}"
     }
     DEFAULT_TIMEOUT_IN_SECONDS = 4
-    DEFAULT_CACHE_SIZE = 10
+    DEFAULT_CACHE_SIZE = 100
     DEFAULT_CACHE_TTL = 15 * 60 # 15 minutes
 
+    def get_raw!(url)
+      do_raw_request(:get, url)
+    end
+
     def get_raw(url)
       ignoring GdsApi::HTTPNotFound do
-        do_raw_request(:get, url)
+        get_raw!(url)
       end
     end
 
@@ -139,13 +153,9 @@ module GdsApi
     # Take a hash of parameters for Request#execute; return a hash of
     # parameters with timeouts included
     def with_timeout(method_params)
-      if options[:disable_timeout]
-        method_params.merge(timeout: -1)
-      else
-        method_params.merge(
-          timeout: options[:timeout] || DEFAULT_TIMEOUT_IN_SECONDS
-        )
-      end
+      method_params.merge(
+        timeout: options[:timeout] || DEFAULT_TIMEOUT_IN_SECONDS
+      )
     end
 
     def with_ssl_options(method_params)
@@ -157,11 +167,32 @@ module GdsApi
 
     def do_request_with_cache(method, url, params = nil)
       # Only read GET requests from the cache: any other request methods should
-      # always be passed through
-      if method == :get
-        @cache[url] ||= do_request(method, url, params)
-      else
-        do_request(method, url, params)
+      # always be passed through. Note that this means HEAD requests won't get
+      # cached, but that would involve separating the cache by method and URL.
+      # Also, we don't generally make HEAD requests.
+      use_cache = (method == :get)
+
+      if use_cache
+        cached_response = @cache[url]
+        return cached_response if cached_response
+      end
+
+      response = do_request(method, url, params)
+
+      if use_cache
+        cache_time = response_cache_time(response)
+        # If cache_time is nil, this will fall back on @cache's default
+        @cache.store(url, response, cache_time)
+      end
+
+      response
+    end
+
+    # Return either a Time object representing the expiry time of the response
+    # or nil if no cache information is provided
+    def response_cache_time(response)
+      if response.headers[:expires]
+        Time.httpdate response.headers[:expires]
       end
     end
 

data/lib/gds_api/{content_api/list_response.rb → list_response.rb}

@@ -2,13 +2,13 @@ require "json"
 require "gds_api/response"
 require "link_header"
 
-class GdsApi::ContentApi < GdsApi::Base
+module GdsApi
 
-  # Response class for lists of multiple items from the content API.
+  # Response class for lists of multiple items.
   #
-  # These responses are in a common format, with the list of results contained
-  # under the `results` key. The response may also have previous and subsequent
-  # pages, indicated by entries in the response's `Link` header.
+  # This expects responses to be in a common format, with the list of results
+  # contained under the `results` key. The response may also have previous and
+  # subsequent pages, indicated by entries in the response's `Link` header.
   class ListResponse < Response
 
     # The ListResponse is instantiated with a reference back to the API client,

data/lib/gds_api/null_cache.rb

@@ -0,0 +1,13 @@
+module GdsApi
+  class NullCache
+    def [](k)
+      nil
+    end
+
+    def []=(k, v)
+    end
+
+    def store(k, v, args={})
+    end
+  end
+end

data/lib/gds_api/response.rb

@@ -3,50 +3,91 @@ require 'ostruct'
 require_relative 'core-ext/openstruct'
 
 module GdsApi
+
+  # This wraps an HTTP response with a JSON body, and presents this as
+  # an object that has the read behaviour of both a Hash and an OpenStruct
+  #
+  # Responses can be configured to use relative URLs for `web_url` properties.
+  # API endpoints should return absolute URLs so that they make sense outside of the
+  # GOV.UK context.  However on internal systems we want to present relative URLs.
+  # By specifying a base URI, this will convert all matching web_urls into relative URLs
+  # This is useful on non-canonical frontends, such as those in staging environments.
+  # See: https://github.com/alphagov/wiki/wiki/API-conventions for details on the API conventions
+  #
+  # Example:
+  #
+  #   r = Response.new(response, web_urls_relative_to: "https://www.gov.uk")
+  #   r.results[0].web_url
+  #   => "/bank-holidays"
   class Response
     extend Forwardable
     include Enumerable
 
+    WEB_URL_KEYS = ["web_url"]
+
     def_delegators :to_hash, :[], :"<=>", :each
 
-    def initialize(http_response)
+    def initialize(http_response, options = {})
       @http_response = http_response
+      @web_urls_relative_to = URI.parse(options[:web_urls_relative_to]) if options[:web_urls_relative_to]
     end
 
     def raw_response_body
       @http_response.body
     end
 
-    def to_hash
-      @parsed ||= JSON.parse(@http_response.body)
-    end
-
     def code
       # Return an integer code for consistency with HTTPErrorResponse
       @http_response.code
     end
 
+    def to_hash
+      @parsed ||= transform_parsed(JSON.parse(@http_response.body))
+    end
+
     def to_ostruct
-      self.class.build_ostruct_recursively(to_hash)
+      @ostruct ||= self.class.build_ostruct_recursively(to_hash)
     end
 
     def method_missing(method)
-      if to_hash.has_key?(method.to_s)
-        to_ostruct.send(method)
-      else
-        nil
-      end
+      to_ostruct.send(method)
     end
 
     def respond_to_missing?(method, include_private)
-      to_hash.has_key?(method.to_s)
+      to_ostruct.respond_to?(method, include_private)
     end
 
-    def present?; ! blank?; end
+    def present?; true; end
     def blank?; false; end
 
   private
 
+    def transform_parsed(value)
+      return value if @web_urls_relative_to.nil?
+
+      case value
+      when Hash
+        Hash[value.map { |k, v|
+          # NOTE: Don't bother transforming if the value is nil
+          if WEB_URL_KEYS.include?(k) && v
+            # Use relative URLs to route when the web_url value is on the
+            # same domain as the site root. Note that we can't just use the
+            # `route_to` method, as this would give us technically correct
+            # but potentially confusing `//host/path` URLs for URLs with the
+            # same scheme but different hosts.
+            relative_url = @web_urls_relative_to.route_to(v)
+            [k, relative_url.host ? v : relative_url.to_s]
+          else
+            [k, transform_parsed(v)]
+          end
+        }]
+      when Array
+        value.map { |v| transform_parsed(v) }
+      else
+        value
+      end
+    end
+
     def self.build_ostruct_recursively(value)
       case value
       when Hash

data/lib/gds_api/rummager.rb

@@ -1,56 +1,35 @@
+require 'gds_api/base'
 require 'rack/utils'
 
 module GdsApi
-  class Rummager
-    class SearchUriNotSpecified < RuntimeError; end
-    class SearchError < RuntimeError; end
-    class SearchServiceError < SearchError; end
-    class SearchTimeout < SearchError; end
-
-    attr_accessor :search_uri
-
-    def initialize(search_uri)
-      raise SearchUriNotSpecified unless search_uri
-      self.search_uri = search_uri
-    end
+  class Rummager < Base
 
     def search(query, format_filter = nil)
       return [] if query.nil? || query == ""
-      JSON.parse(search_response(:search, query, format_filter).body)
+      get_json!(search_url(:search, query, format_filter))
     end
 
     def autocomplete(query, format_filter = nil)
       return [] if query.nil? || query == ""
-      search_response(:autocomplete, query, format_filter).body
+      get_raw!(search_url(:autocomplete, query, format_filter)).body
     end
 
     def advanced_search(args)
       return [] if args.nil? || args.empty?
-      JSON.parse(advanced_search_response(args).body)
+      request_path = "#{base_url}/advanced_search?#{Rack::Utils.build_nested_query(args)}"
+      get_json!(request_path)
     end
 
-    private
-
-    def advanced_search_response(args)
-      request_path = "/advanced_search?#{Rack::Utils.build_nested_query(args)}"
-      get_response(request_path)
-    end
+  private
 
-    def search_response(type, query, format_filter = nil)
-      request_path = "/#{type}?q=#{CGI.escape(query)}"
+    def search_url(type, query, format_filter = nil)
+      request_path = "#{base_url}/#{type}?q=#{CGI.escape(query)}"
       request_path << "&format_filter=#{CGI.escape(format_filter)}" if format_filter
-      get_response(request_path)
+      request_path
     end
 
-    def get_response(request_path)
-      uri = URI("#{search_uri}#{request_path}")
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true if uri.scheme == 'https'
-      response = http.get(uri.request_uri, {"Accept" => "application/json"})
-      raise SearchServiceError.new("#{response.code}: #{response.body}") unless response.code == "200"
-      response
-    rescue Timeout::Error
-      raise SearchTimeout
+    def base_url
+      endpoint
     end
   end
 end

data/lib/gds_api/test_helpers/common_responses.rb

@@ -0,0 +1,36 @@
+module GdsApi
+  module TestHelpers
+    module CommonResponses
+      def titleize_slug(slug, options = {})
+        if options[:title_case]
+          slug.gsub("-", " ").gsub(/\b./) {|m| m.upcase }
+        else
+          slug.gsub("-", " ").capitalize
+        end
+      end
+
+      def response_base
+        {
+          "_response_info" => {
+            "status" => "ok"
+          }
+        }
+      end
+      alias_method :singular_response_base, :response_base
+
+      def plural_response_base
+        response_base.merge(
+          {
+            "description" => "Tags!",
+            "total" => 100,
+            "start_index" => 1,
+            "page_size" => 100,
+            "current_page" => 1,
+            "pages" => 1,
+            "results" => []
+          }
+        )
+      end
+    end
+  end
+end

data/lib/gds_api/test_helpers/content_api.rb

@@ -1,10 +1,11 @@
 require 'gds_api/test_helpers/json_client_helper'
 require 'cgi'
-require_relative 'content_api/artefact_stub'
+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')
@@ -295,38 +296,10 @@ module GdsApi
         raise "Need a licence identifier" if details[:licence_identifier].nil?
         @stubbed_content_api_licences << details
       end
-
-      private
-
-        def titleize_slug(slug)
-          slug.gsub("-", " ").capitalize
-        end
-
-        def response_base
-          {
-            "_response_info" => {
-              "status" => "ok"
-            }
-          }
-        end
-
-        def singular_response_base
-          response_base
-        end
-
-        def plural_response_base
-          response_base.merge(
-            {
-              "description" => "Tags!",
-              "total" => 100,
-              "startIndex" => 1,
-              "pageSize" => 100,
-              "currentPage" => 1,
-              "pages" => 1,
-              "results" => []
-            }
-          )
-        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/json_client_helper.rb

@@ -1,16 +1,4 @@
 require 'gds_api/json_client'
+require 'gds_api/null_cache'
 
-module GdsApi
-  module TestHelpers
-    class NullCache
-      def [](k)
-        nil
-      end
-
-      def []=(k, v)
-      end
-    end
-  end
-end
-
-GdsApi::JsonClient.cache = GdsApi::TestHelpers::NullCache.new
+GdsApi::JsonClient.cache = GdsApi::NullCache.new

data/lib/gds_api/test_helpers/worldwide.rb

@@ -0,0 +1,116 @@
+require 'gds_api/test_helpers/json_client_helper'
+require 'gds_api/test_helpers/common_responses'
+
+module GdsApi
+  module TestHelpers
+    module Worldwide
+      include GdsApi::TestHelpers::CommonResponses
+
+      WORLDWIDE_API_ENDPOINT = Plek.current.find('whitehall-admin')
+
+      # Sets up the index endpoints for the given country slugs
+      # The stubs are setup to paginate in chunks of 20
+      #
+      # This also sets up the individual endpoints for each slug
+      # by calling worldwide_api_has_location below
+      def worldwide_api_has_locations(location_slugs)
+        location_slugs.each {|s| worldwide_api_has_location(s) }
+        pages = []
+        location_slugs.each_slice(20) do |slugs|
+          pages << slugs.map {|s| world_location_details_for_slug(s) }
+        end
+
+        pages.each_with_index do |page, i|
+          page_details = plural_response_base.merge({
+            "results" => page,
+            "total" => location_slugs.size,
+            "pages" => pages.size,
+            "current_page" => i + 1,
+            "page_size" => 20,
+            "start_index" => i * 20 + 1,
+          })
+
+          links = {:self => "#{WORLDWIDE_API_ENDPOINT}/api/world-locations?page=#{i + 1}" }
+          links[:next] = "#{WORLDWIDE_API_ENDPOINT}/api/world-locations?page=#{i + 2}" if pages[i+1]
+          links[:previous] = "#{WORLDWIDE_API_ENDPOINT}/api/world-locations?page=#{i}" unless i == 0
+          page_details["_response_info"]["links"] = []
+          link_headers = []
+          links.each do |rel, href|
+            page_details["_response_info"]["links"] << {"rel" => rel, "href" => href}
+            link_headers << "<#{href}>; rel=\"#{rel}\""
+          end
+
+          stub_request(:get, links[:self]).
+            to_return(:status => 200, :body => page_details.to_json, :headers => {"Link" => link_headers.join(", ")})
+          if i == 0
+            # First page exists at URL with and without page param
+            stub_request(:get, links[:self].sub(/\?page=1/, '')).
+              to_return(:status => 200, :body => page_details.to_json, :headers => {"Link" => link_headers.join(", ")})
+          end
+        end
+      end
+
+      def worldwide_api_has_selection_of_locations
+        worldwide_api_has_locations %w(
+          afghanistan angola australia bahamas belarus brazil brunei cambodia chad
+          croatia denmark eritrea france ghana iceland japan laos luxembourg malta
+          micronesia mozambique nicaragua panama portugal sao-tome-and-principe singapore
+          south-korea sri-lanka uk-delegation-to-council-of-europe
+          uk-delegation-to-organization-for-security-and-co-operation-in-europe
+          united-kingdom venezuela vietnam
+        )
+      end
+
+      def worldwide_api_has_location(location_slug, details=nil)
+        details ||= world_location_for_slug(location_slug)
+        stub_request(:get, "#{WORLDWIDE_API_ENDPOINT}/api/world-locations/#{location_slug}").
+          to_return(:status => 200, :body => details.to_json)
+      end
+
+      def worldwide_api_does_not_have_location(location_slug)
+        stub_request(:get, "#{WORLDWIDE_API_ENDPOINT}/api/world-locations/#{location_slug}").to_return(:status => 404)
+      end
+
+      def worldwide_api_has_organisations_for_location(location_slug, json_or_hash)
+        json = json_or_hash.is_a?(Hash) ? json_or_hash.to_json : json_or_hash
+        url = "#{WORLDWIDE_API_ENDPOINT}/api/world-locations/#{location_slug}/organisations"
+        stub_request(:get, url).
+          to_return(:status => 200, :body => json, :headers => {"Link" => "<#{url}; rel\"self\""})
+      end
+
+      def worldwide_api_has_no_organisations_for_location(location_slug)
+        details = {"results" => [], "total" => 0, "_response_info" => { "status" => "ok" } }
+        url = "#{WORLDWIDE_API_ENDPOINT}/api/world-locations/#{location_slug}/organisations"
+        stub_request(:get, url).
+          to_return(:status => 200, :body => details.to_json, :headers => {"Link" => "<#{url}; rel\"self\""})
+      end
+
+      def world_location_for_slug(slug)
+        singular_response_base.merge(world_location_details_for_slug(slug))
+      end
+
+      # Constructs a sample world_location
+      #
+      # if the slug contains 'delegation' or 'mission' the format will be set to 'International delegation'
+      # othersiwe it will be set to 'World location'
+      def world_location_details_for_slug(slug)
+        {
+          "id" => "https://www.gov.uk/api/world-locations/#{slug}",
+          "title" => titleize_slug(slug, :title_case => true),
+          "format" => (slug =~ /(delegation|mission)/ ? "International delegation" : "World location"),
+          "updated_at" => "2013-03-25T13:06:42+00:00",
+          "web_url" => "https://www.gov.uk/government/world/#{slug}",
+          "details" => {
+            "slug" => slug,
+            "iso2" => slug[0..1].upcase,
+          },
+          "organisations" => {
+            "id" => "https://www.gov.uk/api/world-locations/#{slug}/organisations",
+            "web_url" => "https://www.gov.uk/government/world/#{slug}#organisations"
+          },
+        }
+      end
+
+    end
+  end
+end

data/lib/gds_api/version.rb

@@ -1,3 +1,3 @@
 module GdsApi
-  VERSION = '5.5.0'
+  VERSION = '6.0.0'
 end

data/lib/gds_api/worldwide.rb

@@ -0,0 +1,21 @@
+require_relative 'base'
+
+class GdsApi::Worldwide < GdsApi::Base
+
+  def world_locations
+    get_list! "#{base_url}/world-locations"
+  end
+
+  def world_location(location_slug)
+    get_json "#{base_url}/world-locations/#{location_slug}"
+  end
+
+  def organisations_for_world_location(location_slug)
+    get_list! "#{base_url}/world-locations/#{location_slug}/organisations"
+  end
+
+private
+  def base_url
+    "#{endpoint}/api"
+  end
+end