gds-api-adapters 38.0.0 → 38.1.0

data/test/licence_application_api_test.rb

@@ -20,8 +20,8 @@ class LicenceApplicationApiTest < Minitest::Test
   def test_should_return_list_of_licences
     stub_request(:get, "#{@core_url}/api/licences").
       with(headers: GdsApi::JsonClient.default_request_headers).
-      to_return(:status => 200,
-                :body => <<-EOS
+      to_return(status: 200,
+                body: <<-EOS
 [
    {
       "code":"1324-5-1",
@@ -81,11 +81,11 @@ EOS
   end
 
   def test_should_provide_full_licence_details_for_canonical_id
-    licence_exists('590001', {"isLocationSpecific" => true, "geographicalAvailability" => ["England","Wales"], "issuingAuthorities" => []})
+    licence_exists('590001', "isLocationSpecific" => true, "geographicalAvailability" => %w(England Wales), "issuingAuthorities" => [])
 
     expected = {
       "isLocationSpecific" => true,
-      "geographicalAvailability" => ["England", "Wales"],
+      "geographicalAvailability" => %w(England Wales),
       "issuingAuthorities" => []
     }
 
@@ -172,12 +172,10 @@ EOS
 
     assert_equal true, response["isLocationSpecific"]
 
-    assert_includes response["issuingAuthorities"][0]["authorityInteractions"]["apply"], {
-      "url" => "https://www.gov.uk/motor-salvage-operator-registration/city-of-london/apply-1",
+    assert_includes response["issuingAuthorities"][0]["authorityInteractions"]["apply"], "url" => "https://www.gov.uk/motor-salvage-operator-registration/city-of-london/apply-1",
       "usesLicensify" => true,
       "description" => "Application to register as a motor salvage operator",
       "payment" => "none"
-    }
   end
 
   def test_should_raise_exception_on_timeout

data/test/list_response_test.rb

@@ -2,24 +2,19 @@ require_relative 'test_helper'
 require 'gds_api/list_response'
 
 describe GdsApi::ListResponse do
-
   describe "accessing results" do
     before :each do
     end
 
     it "should allow Enumerable access to the results array" do
       data = {
-        "results" => [
-          "foo",
-          "bar",
-          "baz",
-        ],
+        "results" => %w(foo bar baz),
         "total" => 3,
         "_response_info" => {
           "status" => "ok",
         }
       }
-      response = GdsApi::ListResponse.new(stub(:body => data.to_json), nil)
+      response = GdsApi::ListResponse.new(stub(body: data.to_json), nil)
 
       assert_equal "foo", response.first
       assert_equal %w(foo bar baz), response.to_a
@@ -34,7 +29,7 @@ describe GdsApi::ListResponse do
           "status" => "ok",
         }
       }
-      response = GdsApi::ListResponse.new(stub(:body => data.to_json), nil)
+      response = GdsApi::ListResponse.new(stub(body: data.to_json), nil)
 
       assert_equal [], response.to_a
       assert ! response.any?
@@ -44,39 +39,39 @@ describe GdsApi::ListResponse do
   describe "handling pagination" do
     before :each do
       page_1 = {
-        "results" => ["foo1", "bar1"],
+        "results" => %w(foo1 bar1),
         "total" => 6,
         "current_page" => 1, "pages" => 3, "page_size" => 2,
         "_response_info" => {
           "status" => "ok",
           "links" => [
-            {"href" => "http://www.example.com/2", "rel" => "next"},
-            {"href" => "http://www.example.com/1", "rel" => "self"},
+            { "href" => "http://www.example.com/2", "rel" => "next" },
+            { "href" => "http://www.example.com/1", "rel" => "self" },
           ]
         }
       }
       page_2 = {
-        "results" => ["foo2", "bar2"],
+        "results" => %w(foo2 bar2),
         "total" => 6,
         "current_page" => 2, "pages" => 3, "page_size" => 2,
         "_response_info" => {
           "status" => "ok",
           "links" => [
-            {"href" => "http://www.example.com/1", "rel" => "previous"},
-            {"href" => "http://www.example.com/3", "rel" => "next"},
-            {"href" => "http://www.example.com/2", "rel" => "self"},
+            { "href" => "http://www.example.com/1", "rel" => "previous" },
+            { "href" => "http://www.example.com/3", "rel" => "next" },
+            { "href" => "http://www.example.com/2", "rel" => "self" },
           ]
         }
       }
       page_3 = {
-        "results" => ["foo3", "bar3"],
+        "results" => %w(foo3 bar3),
         "total" => 6,
         "current_page" => 3, "pages" => 3, "page_size" => 2,
         "_response_info" => {
           "status" => "ok",
           "links" => [
-            {"href" => "http://www.example.com/2", "rel" => "previous"},
-            {"href" => "http://www.example.com/3", "rel" => "self"},
+            { "href" => "http://www.example.com/2", "rel" => "previous" },
+            { "href" => "http://www.example.com/3", "rel" => "self" },
           ]
         }
       }
@@ -102,10 +97,10 @@ describe GdsApi::ListResponse do
         }
       )
 
-      @client = stub()
-      @client.stubs(:get_list!).with("http://www.example.com/1").returns(GdsApi::ListResponse.new(@p1_response, @client))
-      @client.stubs(:get_list!).with("http://www.example.com/2").returns(GdsApi::ListResponse.new(@p2_response, @client))
-      @client.stubs(:get_list!).with("http://www.example.com/3").returns(GdsApi::ListResponse.new(@p3_response, @client))
+      @client = stub
+      @client.stubs(:get_list).with("http://www.example.com/1").returns(GdsApi::ListResponse.new(@p1_response, @client))
+      @client.stubs(:get_list).with("http://www.example.com/2").returns(GdsApi::ListResponse.new(@p2_response, @client))
+      @client.stubs(:get_list).with("http://www.example.com/3").returns(GdsApi::ListResponse.new(@p3_response, @client))
     end
 
     describe "accessing next page" do
@@ -125,8 +120,8 @@ describe GdsApi::ListResponse do
         resp = GdsApi::ListResponse.new(@p1_response, @client)
         first_call = resp.next_page
 
-        @client.unstub(:get_list!) # Necessary because of https://github.com/freerange/mocha/issues/44
-        @client.expects(:get_list!).never
+        @client.unstub(:get_list) # Necessary because of https://github.com/freerange/mocha/issues/44
+        @client.expects(:get_list).never
         second_call = resp.next_page
         assert_equal first_call, second_call
       end
@@ -149,8 +144,8 @@ describe GdsApi::ListResponse do
         resp = GdsApi::ListResponse.new(@p3_response, @client)
         first_call = resp.previous_page
 
-        @client.unstub(:get_list!) # Necessary because of https://github.com/freerange/mocha/issues/44
-        @client.expects(:get_list!).never
+        @client.unstub(:get_list) # Necessary because of https://github.com/freerange/mocha/issues/44
+        @client.expects(:get_list).never
         second_call = resp.previous_page
         assert_equal first_call, second_call
       end
@@ -164,13 +159,13 @@ describe GdsApi::ListResponse do
       it "should allow iteration across multiple pages" do
         assert_equal 6, @response.with_subsequent_pages.count
         assert_equal %w(foo1 bar1 foo2 bar2 foo3 bar3), @response.with_subsequent_pages.to_a
-        assert_equal %w(foo1 foo2 foo3), @response.with_subsequent_pages.select {|s| s =~ /foo/}
+        assert_equal %w(foo1 foo2 foo3), @response.with_subsequent_pages.select { |s| s =~ /foo/ }
       end
 
       it "should not load a page multiple times" do
-        @client.unstub(:get_list!) # Necessary because of https://github.com/freerange/mocha/issues/44
-        @client.expects(:get_list!).with("http://www.example.com/2").once.returns(GdsApi::ListResponse.new(@p2_response, @client))
-        @client.expects(:get_list!).with("http://www.example.com/3").once.returns(GdsApi::ListResponse.new(@p3_response, @client))
+        @client.unstub(:get_list) # Necessary because of https://github.com/freerange/mocha/issues/44
+        @client.expects(:get_list).with("http://www.example.com/2").once.returns(GdsApi::ListResponse.new(@p2_response, @client))
+        @client.expects(:get_list).with("http://www.example.com/3").once.returns(GdsApi::ListResponse.new(@p3_response, @client))
 
         3.times do
           @response.with_subsequent_pages.to_a
@@ -179,13 +174,13 @@ describe GdsApi::ListResponse do
 
       it "should work with a non-paginated response" do
         data = {
-          "results" => ["foo1", "bar1"],
+          "results" => %w(foo1 bar1),
           "total" => 2,
           "_response_info" => {
             "status" => "ok",
           }
         }
-        response = GdsApi::ListResponse.new(stub(:body => data.to_json, :status => 200, :headers => {}), nil)
+        response = GdsApi::ListResponse.new(stub(body: data.to_json, status: 200, headers: {}), nil)
 
         assert_equal %w(foo1 bar1), response.with_subsequent_pages.to_a
       end

data/test/mapit_test.rb

@@ -12,22 +12,22 @@ describe GdsApi::Mapit do
 
   describe "postcodes" do
     it "should return the coordinates" do
-      mapit_has_a_postcode("SW1A 1AA", [ 51.5010096, -0.1415870 ])
+      mapit_has_a_postcode("SW1A 1AA", [51.5010096, -0.1415870])
 
       response = @api.location_for_postcode("SW1A 1AA")
       assert_equal 51.5010096, response.lat
-      assert_equal -0.1415870, response.lon
+      assert_equal(-0.1415870, response.lon)
     end
 
     it "should return the postcode" do
-      mapit_has_a_postcode("SW1A 1AA", [ 51.5010096, -0.1415870 ])
+      mapit_has_a_postcode("SW1A 1AA", [51.5010096, -0.1415870])
 
       response = @api.location_for_postcode("SW1A 1AA")
       assert_equal "SW1A 1AA", response.postcode
     end
 
     it "should return areas" do
-      mapit_has_a_postcode_and_areas("SW1A 1AA", [ 51.5010096, -0.1415870 ], [
+      mapit_has_a_postcode_and_areas("SW1A 1AA", [51.5010096, -0.1415870], [
         { 'name' => 'Lancashire County Council', 'type' => 'CTY', 'ons' => '30', 'gss' => 'E10000017' },
         { 'name' => 'South Ribble Borough Council', 'type' => 'DIS', 'ons' => '30UN', 'gss' => 'E07000126' }
       ])
@@ -64,11 +64,9 @@ describe GdsApi::Mapit do
 
   describe "areas_for_type" do
     before do
-       mapit_has_areas('EUR', {
-        "123" => { "name" => "Eastern", "id" => "123", "country_name" => "England" },
-        "234" => { "name" => "North West", "id" => "234", "country_name" => "England" },
-        "345" => { "name" => "Scotland", "id" => "345", "country_name" => "Scotland" }
-      })
+      mapit_has_areas('EUR', "123" => { "name" => "Eastern", "id" => "123", "country_name" => "England" },
+       "234" => { "name" => "North West", "id" => "234", "country_name" => "England" },
+       "345" => { "name" => "Scotland", "id" => "345", "country_name" => "Scotland" })
       mapit_does_not_have_areas('FOO')
     end
     it "should return areas of a type" do

data/test/middleware/govuk_header_sniffer_test.rb

@@ -5,7 +5,7 @@ describe GdsApi::GovukHeaderSniffer do
   include Rack::Test::Methods
 
   let(:inner_app) do
-    lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['All good!']] }
+    lambda { |_env| [200, { 'Content-Type' => 'text/plain' }, ['All good!']] }
   end
 
   let(:app) { GdsApi::GovukHeaderSniffer.new(inner_app, 'HTTP_GOVUK_REQUEST_ID') }

data/test/need_api_test.rb

@@ -35,7 +35,7 @@ describe GdsApi::NeedApi do
     end
 
     it "returns a list of needs matching the IDs" do
-      needs = @api.needs_by_id(1,2,3)
+      needs = @api.needs_by_id(1, 2, 3)
 
       assert_equal 3, needs.count
       assert_equal %w(1 2 3), needs.map { |need| need['id'] }
@@ -45,7 +45,7 @@ describe GdsApi::NeedApi do
     end
 
     it "makes the same request regardless of the order of the IDs" do
-      needs = @api.needs_by_id(2,1,3)
+      needs = @api.needs_by_id(2, 1, 3)
 
       assert_equal 3, needs.count
       assert_equal %w(1 2 3), needs.map { |need| need['id'] }
@@ -139,9 +139,9 @@ describe GdsApi::NeedApi do
   describe "creating needs" do
     it "should post to the right endpoint" do
       request_stub = stub_request(:post, @base_api_url + "/needs").with(
-        :body => '{"goal":"I wanna sammich!"}'
+        body: '{"goal":"I wanna sammich!"}'
       )
-      @api.create_need({"goal" => "I wanna sammich!"})
+      @api.create_need("goal" => "I wanna sammich!")
       assert_requested(request_stub)
     end
   end
@@ -278,10 +278,10 @@ describe GdsApi::NeedApi do
 
     it "should return organisations with abbreviations if present" do
       request_stub = need_api_has_organisations(
-        "committee-on-climate-change" => {"name" => "Committee on Climate Change",
-                                          "abbreviation" => "CCC"},
-        "competition-commission" => {"name" => "Competition Commission",
-                                     "abbreviation" => "CC"}
+        "committee-on-climate-change" => { "name" => "Committee on Climate Change",
+                                          "abbreviation" => "CCC" },
+        "competition-commission" => { "name" => "Competition Commission",
+                                     "abbreviation" => "CC" }
       )
       orgs = @api.organisations
 

data/test/organisations_api_test.rb

@@ -21,7 +21,7 @@ describe GdsApi::Organisations do
     end
 
     it "should handle the pagination" do
-      organisation_slugs = (1..50).map {|n| "organisation-#{n}" }
+      organisation_slugs = (1..50).map { |n| "organisation-#{n}" }
       organisations_api_has_organisations(organisation_slugs)
 
       response = @api.organisations
@@ -32,7 +32,7 @@ describe GdsApi::Organisations do
     end
 
     it "should raise error if endpoint 404s" do
-      stub_request(:get, "#{@base_api_url}/api/organisations").to_return(:status => 404)
+      stub_request(:get, "#{@base_api_url}/api/organisations").to_return(status: 404)
       assert_raises GdsApi::HTTPNotFound do
         @api.organisations
       end

data/test/panopticon_registerer_test.rb

@@ -11,7 +11,7 @@ describe GdsApi::Panopticon::Registerer do
       it "should create an instance using the current Plek environment as the platform by default" do
         Plek.stubs(:current).returns(stub(find: "http://thisplace"))
 
-        GdsApi::Panopticon.expects(:new).with("http://thisplace", anything()).returns(:panopticon_instance)
+        GdsApi::Panopticon.expects(:new).with("http://thisplace", anything).returns(:panopticon_instance)
         r = GdsApi::Panopticon::Registerer.new({})
         assert_equal :panopticon_instance, r.send(:panopticon)
       end
@@ -19,28 +19,28 @@ describe GdsApi::Panopticon::Registerer do
       it "should pass through the endpoint url" do
         Plek.stubs(:current).returns(stub(find: "http://thisplace"))
 
-        GdsApi::Panopticon.expects(:new).with("http://otherplace", anything()).returns(:panopticon_instance)
-        r = GdsApi::Panopticon::Registerer.new({endpoint_url: "http://otherplace"})
+        GdsApi::Panopticon.expects(:new).with("http://otherplace", anything).returns(:panopticon_instance)
+        r = GdsApi::Panopticon::Registerer.new(endpoint_url: "http://otherplace")
         assert_equal :panopticon_instance, r.send(:panopticon)
       end
     end
 
     describe "setting other options" do
       it "should create an instance with a default timeout of 10 seconds" do
-        GdsApi::Panopticon.expects(:new).with(anything(), {timeout: 10}).returns(:panopticon_instance)
+        GdsApi::Panopticon.expects(:new).with(anything, timeout: 10).returns(:panopticon_instance)
         r = GdsApi::Panopticon::Registerer.new({})
         assert_equal :panopticon_instance, r.send(:panopticon)
       end
 
       it "should allow overriding the timeout" do
-        GdsApi::Panopticon.expects(:new).with(anything(), {timeout: 15}).returns(:panopticon_instance)
-        r = GdsApi::Panopticon::Registerer.new({timeout: 15})
+        GdsApi::Panopticon.expects(:new).with(anything, timeout: 15).returns(:panopticon_instance)
+        r = GdsApi::Panopticon::Registerer.new(timeout: 15)
         assert_equal :panopticon_instance, r.send(:panopticon)
       end
 
       it "shoule merge in the api credentials" do
-        GdsApi::Panopticon::Registerer.any_instance.stubs(:panopticon_api_credentials).returns({foo: "Bar", baz: "kablooie"})
-        GdsApi::Panopticon.expects(:new).with(anything(), {timeout: 10, foo: "Bar", baz: "kablooie"}).returns(:panopticon_instance)
+        GdsApi::Panopticon::Registerer.any_instance.stubs(:panopticon_api_credentials).returns(foo: "Bar", baz: "kablooie")
+        GdsApi::Panopticon.expects(:new).with(anything, timeout: 10, foo: "Bar", baz: "kablooie").returns(:panopticon_instance)
         r = GdsApi::Panopticon::Registerer.new({})
         assert_equal :panopticon_instance, r.send(:panopticon)
       end
@@ -63,7 +63,7 @@ describe GdsApi::Panopticon::Registerer do
       name: 'A guide to beards',
       description: '5 tips for keeping your beard in check',
       state: 'draft',
-      need_ids: ["100001", "100002"],
+      need_ids: %w(100001 100002),
       public_timestamp: "2014-01-01T12:00:00+00:00",
       latest_change_note: 'Added more stubble',
       content_id: 'f47b4fab-46fa-4020-97a2-3413a5d75402'
@@ -78,7 +78,7 @@ describe GdsApi::Panopticon::Registerer do
         title: 'A guide to beards',
         description: '5 tips for keeping your beard in check',
         state: 'draft',
-        need_ids: ["100001", "100002"],
+        need_ids: %w(100001 100002),
         primary_section: "tax/vat",
         sections: ["tax/vat", "tax/capital-gains"],
         specialist_sectors: ["oil-and-gas/wells", "oil-and-gas/licensing"],

data/test/panopticon_test.rb

@@ -44,13 +44,13 @@ describe GdsApi::Panopticon do
 
   it 'fetches an artefact as a hash given a slug' do
     panopticon_has_metadata(basic_artefact)
-    artefact = api.artefact_for_slug(basic_artefact[:slug], :as_hash => true)
+    artefact = api.artefact_for_slug(basic_artefact[:slug], as_hash: true)
     assert_equal basic_artefact[:name], artefact['name']
   end
 
   it 'fetches and parses JSON into a hash' do
     url = "#{base_api_endpoint}/some.json"
-    stub_request(:get, url).to_return(body: {a:1}.to_json)
+    stub_request(:get, url).to_return(body: { a: 1 }.to_json)
 
     assert_equal 1, api.get_json(url)['a']
   end
@@ -110,7 +110,7 @@ describe GdsApi::Panopticon do
   end
 
   it 'uses basic auth' do
-    credentials = {user: 'fred', password: 'secret'}
+    credentials = { user: 'fred', password: 'secret' }
     api = GdsApi::Panopticon.new('http://some.url', basic_auth: credentials)
     url = "http://#{credentials[:user]}:#{credentials[:password]}@some.url/artefacts/1.json"
     stub_request(:put, url)
@@ -121,7 +121,7 @@ describe GdsApi::Panopticon do
 
   it 'registers new artefacts en masse' do
     r = GdsApi::Panopticon::Registerer.new(endpoint_url: base_api_endpoint, owning_app: 'my-app')
-    artefact = registerable_artefact()
+    artefact = registerable_artefact
     panopticon_has_no_metadata_for('foo')
 
     stub_request(:put, "#{base_api_endpoint}/artefacts/foo.json")
@@ -138,7 +138,7 @@ describe GdsApi::Panopticon do
   end
 
   it 'registers existing artefacts en masse' do
-    artefact = registerable_artefact()
+    artefact = registerable_artefact
     r = GdsApi::Panopticon::Registerer.new(endpoint_url: base_api_endpoint, owning_app: 'my-app')
 
     panopticon_has_metadata(artefact)

data/test/pp_data_in_test.rb

@@ -11,7 +11,7 @@ describe GdsApi::PerformancePlatform::DataIn do
   end
 
   it "can submit a day aggregate for service feedback for a particular slug" do
-    request_details = {"some"=> "data"}
+    request_details = { "some" => "data" }
 
     stub_post = stub_service_feedback_day_aggregate_submission("some-slug", request_details)
 
@@ -21,7 +21,7 @@ describe GdsApi::PerformancePlatform::DataIn do
   end
 
   it "can submit entries counts for corporate content problem reports" do
-    entries = ["some", "entries"]
+    entries = %w(some entries)
 
     stub_post = stub_corporate_content_problem_report_count_submission(entries)
 
@@ -31,7 +31,7 @@ describe GdsApi::PerformancePlatform::DataIn do
   end
 
   it "can submit the corporate content urls with the most problem reports" do
-    entries = ["some", "entries"]
+    entries = %w(some entries)
 
     stub_post = stub_corporate_content_urls_with_the_most_problem_reports_submission(entries)
 

data/test/publishing_api_test.rb

@@ -44,8 +44,6 @@ describe GdsApi::PublishingApi do
     it "returns 200 OK if intent existed and was deleted" do
       base_path = "/test-intent"
 
-      publish_intent = intent_for_publishing_api(base_path)
-
       publishing_api
         .given("a publish intent exists at /test-intent")
         .upon_receiving("a request to delete a publish intent")
@@ -68,8 +66,6 @@ describe GdsApi::PublishingApi do
     it "returns 404 Not found if the intent does not exist" do
       base_path = "/test-intent"
 
-      publish_intent = intent_for_publishing_api(base_path)
-
       publishing_api
         .given("no content exists")
         .upon_receiving("a request to delete a publish intent")
@@ -143,9 +139,9 @@ describe GdsApi::PublishingApi do
           body: {
             "error" => {
               "code" => 422,
-              "message" => Pact.term(generate: "Unprocessable", matcher:/\S+/),
+              "message" => Pact.term(generate: "Unprocessable", matcher: /\S+/),
               "fields" => {
-                "base_path" => Pact.each_like("has been reserved", :min => 1),
+                "base_path" => Pact.each_like("has been reserved", min: 1),
               },
             },
           },