gds-api-adapters 38.1.0 → 39.0.0

data/test/mapit_test.rb

@@ -1,117 +0,0 @@
-require 'test_helper'
-require 'gds_api/mapit'
-require 'gds_api/test_helpers/mapit'
-
-describe GdsApi::Mapit do
-  include GdsApi::TestHelpers::Mapit
-
-  before do
-    @base_api_url = Plek.current.find("mapit")
-    @api = GdsApi::Mapit.new(@base_api_url)
-  end
-
-  describe "postcodes" do
-    it "should return the coordinates" do
-      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)
-    end
-
-    it "should return the postcode" do
-      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], [
-        { 'name' => 'Lancashire County Council', 'type' => 'CTY', 'ons' => '30', 'gss' => 'E10000017' },
-        { 'name' => 'South Ribble Borough Council', 'type' => 'DIS', 'ons' => '30UN', 'gss' => 'E07000126' }
-      ])
-
-      response = @api.location_for_postcode("SW1A 1AA")
-      assert_equal 2, response.areas.length
-
-      assert_equal "Lancashire County Council", response.areas.first.name
-      assert_equal "South Ribble Borough Council", response.areas.last.name
-
-      assert_equal "CTY", response.areas.first.type
-      assert_equal "DIS", response.areas.last.type
-
-      assert_equal "30", response.areas.first.codes['ons']
-      assert_equal "30UN", response.areas.last.codes['ons']
-    end
-
-    it "should raise if a postcode doesn't exist" do
-      mapit_does_not_have_a_postcode("SW1A 1AA")
-
-      assert_raises(GdsApi::HTTPNotFound) do
-        @api.location_for_postcode("SW1A 1AA")
-      end
-    end
-
-    it "should return 400 for an invalid postcode" do
-      mapit_does_not_have_a_bad_postcode("B4DP05TC0D3")
-
-      assert_raises GdsApi::HTTPClientError do
-        @api.location_for_postcode("B4DP05TC0D3")
-      end
-    end
-  end
-
-  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_does_not_have_areas('FOO')
-    end
-    it "should return areas of a type" do
-      areas = @api.areas_for_type('EUR').to_hash
-
-      assert_equal 3, areas.size
-      assert_equal "Eastern", areas["123"]["name"]
-      assert_equal "England", areas["123"]["country_name"]
-      assert_equal "North West", areas["234"]["name"]
-      assert_equal "England", areas["234"]["country_name"]
-      assert_equal "Scotland", areas["345"]["name"]
-      assert_equal "Scotland", areas["345"]["country_name"]
-    end
-    it "should return and empty result for an unknown area type" do
-      response = @api.areas_for_type('FOO')
-
-      assert_empty response.parsed_content
-    end
-  end
-
-  describe "area_for_code" do
-    before do
-      south_ribble_area = {
-        name: "South Ribble Borough Council",
-        codes: {
-          ons: "30UN",
-          gss: "E07000126",
-          unit_id: "4834"
-        },
-        type: "DIS"
-      }
-      mapit_has_area_for_code('ons', '30UN', south_ribble_area)
-      mapit_does_not_have_area_for_code('govuk_slug', 'neverland')
-    end
-
-    it "should return area for a code type" do
-      area = @api.area_for_code('ons', '30UN')
-
-      assert_equal "South Ribble Borough Council", area["name"]
-    end
-
-    it "should return 404 for a missing area of a certain code type" do
-      assert_raises(GdsApi::HTTPNotFound) do
-        @api.area_for_code('govuk_slug', 'neverland')
-      end
-    end
-  end
-end

data/test/maslow_test.rb

@@ -1,12 +0,0 @@
-require 'test_helper'
-require 'gds_api/maslow'
-
-describe GdsApi::Maslow do
-  before do
-    @api = GdsApi::Maslow.new("http://maslow.dev.gov.uk")
-  end
-
-  it "should provide a URL to need pages" do
-    assert_equal "http://maslow.dev.gov.uk/needs/12345", @api.need_page_url(12345)
-  end
-end

data/test/middleware/govuk_header_sniffer_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-require 'gds_api/middleware/govuk_header_sniffer'
-
-describe GdsApi::GovukHeaderSniffer do
-  include Rack::Test::Methods
-
-  let(:inner_app) do
-    lambda { |_env| [200, { 'Content-Type' => 'text/plain' }, ['All good!']] }
-  end
-
-  let(:app) { GdsApi::GovukHeaderSniffer.new(inner_app, 'HTTP_GOVUK_REQUEST_ID') }
-
-  it "sniffs custom request headers and stores them for later use" do
-    header "Govuk-Request-Id", "12345"
-    get "/"
-    assert_equal '12345', GdsApi::GovukHeaders.headers[:govuk_request_id]
-  end
-end

data/test/need_api_test.rb

@@ -1,345 +0,0 @@
-require 'test_helper'
-require 'gds_api/need_api'
-require 'gds_api/test_helpers/need_api'
-
-describe GdsApi::NeedApi do
-  include GdsApi::TestHelpers::NeedApi
-
-  before do
-    @base_api_url = Plek.current.find("need-api")
-    @api = GdsApi::NeedApi.new(@base_api_url)
-  end
-
-  describe "requesting needs by ID" do
-    before do
-      need_api_has_need_ids([
-        {
-          "id"   => "1",
-          "role" => "parent",
-          "goal" => "apply for a primary school place",
-          "benefit" => "my child can start school",
-        },
-        {
-          "id"   => "2",
-          "role" => "user",
-          "goal" => "find out about becoming a British citizen",
-          "benefit" => "i can take the correct steps to apply for citizenship",
-        },
-        {
-          "id"   => "3",
-          "role" => "user",
-          "goal" => "find out about unemployment benefits",
-          "benefit" => "i have financial support whilst unemployed",
-        }
-      ])
-    end
-
-    it "returns a list of needs matching the IDs" do
-      needs = @api.needs_by_id(1, 2, 3)
-
-      assert_equal 3, needs.count
-      assert_equal %w(1 2 3), needs.map { |need| need['id'] }
-      assert_equal "apply for a primary school place", needs['results'][0]['goal']
-      assert_equal "find out about becoming a British citizen", needs['results'][1]['goal']
-      assert_equal "find out about unemployment benefits", needs['results'][2]['goal']
-    end
-
-    it "makes the same request regardless of the order of the IDs" do
-      needs = @api.needs_by_id(2, 1, 3)
-
-      assert_equal 3, needs.count
-      assert_equal %w(1 2 3), needs.map { |need| need['id'] }
-    end
-
-    it "correctly sorts IDs requested as strings" do
-      needs = @api.needs_by_id(%w(02 3 1))
-
-      assert_equal 3, needs.count
-      assert_equal %w(1 2 3), needs.map { |need| need['id'] }
-    end
-  end
-
-  describe "requesting needs" do
-    it "should return a list of all needs" do
-      req = need_api_has_needs([
-        {
-          "role" => "parent",
-          "goal" => "apply for a primary school place",
-          "benefit" => "my child can start school",
-          "organisation_ids" => ["department-for-education"],
-          "organisations" => [
-            {
-              "id" => "department-for-education",
-              "name" => "Department for Education",
-            }
-          ],
-          "justifications" => [
-            "it's something only government does",
-            "the government is legally obliged to provide it"
-          ],
-          "impact" => "Has serious consequences for the day-to-day lives of your users",
-          "met_when" => [
-            "The user applies for a school place"
-          ]
-        },
-        {
-          "role" => "user",
-          "goal" => "find out about becoming a British citizen",
-          "benefit" => "i can take the correct steps to apply for citizenship",
-          "organisation_ids" => ["home-office"],
-          "organisations" => [
-            {
-              "id" => "home-office",
-              "name" => "Home Office",
-            }
-          ],
-          "justifications" => [
-            "it's something only government does",
-            "the government is legally obliged to provide it"
-          ],
-          "impact" => "Has serious consequences for the day-to-day lives of your users",
-          "met_when" => [
-            "The user finds information about the citizenship test and the next steps"
-          ]
-        }
-      ])
-
-      needs = @api.needs
-
-      assert_requested(req)
-      assert_equal 2, needs.count
-
-      assert_equal %w(parent user), needs.map { |need| need['role'] }
-      assert_equal(
-        [
-          "apply for a primary school place",
-          "find out about becoming a British citizen"
-        ],
-        needs.map { |need| need['goal'] }
-      )
-      assert_equal(
-        [
-          "my child can start school",
-          "i can take the correct steps to apply for citizenship"
-        ],
-        needs.map { |need| need['benefit'] }
-      )
-
-      assert_equal(
-        "department-for-education",
-        needs.first['organisations'].first['id']
-      )
-      assert_equal(
-        "Department for Education",
-        needs.first['organisations'].first['name']
-      )
-    end
-  end
-
-  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!"}'
-      )
-      @api.create_need("goal" => "I wanna sammich!")
-      assert_requested(request_stub)
-    end
-  end
-
-  describe "filtering needs by organisation" do
-    it "should return a subset of needs" do
-      req = need_api_has_needs_for_organisation("ministry-of-justice", [
-        {
-          "role" => "parent",
-          "goal" => "apply for a primary school place",
-          "benefit" => "my child can start school",
-          "organisation_ids" => ["ministry-of-justice"],
-          "organisations" => [
-            {
-              "id" => "ministry-of-justice",
-              "name" => "Ministry of Justice",
-            }
-          ],
-          "justifications" => [
-            "it's something only government does",
-            "the government is legally obliged to provide it"
-          ],
-          "impact" => "Has serious consequences for the day-to-day lives of your users",
-          "met_when" => [
-            "The user applies for a school place"
-          ]
-        },
-        {
-          "role" => "user",
-          "goal" => "find out about becoming a British citizen",
-          "benefit" => "i can take the correct steps to apply for citizenship",
-          "organisation_ids" => ["ministry-of-justice"],
-          "organisations" => [
-            {
-              "id" => "ministry-of-justice",
-              "name" => "Ministry of Justice",
-            }
-          ],
-          "justifications" => [
-            "it's something only government does",
-            "the government is legally obliged to provide it"
-          ],
-          "impact" => "Has serious consequences for the day-to-day lives of your users",
-          "met_when" => [
-            "The user finds information about the citizenship test and the next steps"
-          ]
-        }
-      ])
-
-      @api.needs(organisation_id: "ministry-of-justice")
-      assert_requested(req)
-    end
-  end
-
-  describe "viewing needs" do
-    it "should return a need response" do
-      need = {
-        id: 100500,
-        role: "parent",
-        goal: "do things",
-        benefit: "good things"
-      }
-      need_api_has_need(need)
-
-      need_response = @api.need(100500)
-      assert_equal "good things", need_response['benefit']
-    end
-
-    it "should raise for a missing need" do
-      need_api_has_no_need(100600)
-
-      assert_raises(GdsApi::HTTPNotFound) do
-        @api.need(100600)
-      end
-    end
-  end
-
-  describe "viewing content_ids for needs" do
-    it "should return the content_id for a need_id" do
-      need = {
-        id: 100700,
-        content_id: "abcdef-12345",
-        role: "need",
-        goal: "needy",
-        benefit: "needless"
-      }
-      need_api_has_content_id_for_need(need)
-
-      need_response = @api.content_id(100700)
-      assert_equal 'abcdef-12345', need_response.body
-    end
-  end
-
-  describe "updating needs" do
-    it "should send a PUT request" do
-      updated_fields = {
-        role: "parent",
-        goal: "do things",
-        benefit: "good things"
-      }
-
-      update_stub = stub_request(:put, @base_api_url + "/needs/100005")
-                        .with(body: updated_fields.to_json)
-                        .to_return(status: 204)
-      @api.update_need(100005, updated_fields)
-      assert_requested update_stub
-    end
-
-    it "should accept partial updates" do
-      updated_fields = { role: "parent" }
-
-      update_stub = stub_request(:put, @base_api_url + "/needs/100005")
-                        .with(body: updated_fields.to_json)
-                        .to_return(status: 204)
-      @api.update_need(100005, updated_fields)
-      assert_requested update_stub
-    end
-  end
-
-  describe "viewing organisations" do
-    it "should return a list of organisations" do
-      request_stub = need_api_has_organisations(
-        "committee-on-climate-change" => "Committee on Climate Change",
-        "competition-commission" => "Competition Commission"
-      )
-
-      orgs = @api.organisations
-
-      assert_requested(request_stub)
-      assert_equal "Committee on Climate Change", orgs[0]["name"]
-      assert_equal "Competition Commission", orgs[1]["name"]
-      assert_equal 2, orgs.size
-    end
-
-    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" }
-      )
-      orgs = @api.organisations
-
-      assert_requested(request_stub)
-      assert_equal "Committee on Climate Change", orgs[0]["name"]
-      assert_equal "Competition Commission", orgs[1]["name"]
-      assert_equal "CCC", orgs[0]["abbreviation"]
-      assert_equal "CC", orgs[1]["abbreviation"]
-      assert_equal 2, orgs.size
-    end
-  end
-
-  describe "closing needs as duplicates" do
-    it "should send a PUT request" do
-      fields = {
-        duplicate_of: 100001
-      }
-
-      duplicate_stub = stub_request(:put, @base_api_url + "/needs/100005/closed")
-                         .with(body: fields.to_json)
-                         .to_return(status: 204)
-      @api.close(100005, fields)
-      assert_requested duplicate_stub
-    end
-  end
-
-  describe "reopening closed needs" do
-    it "should send a DELETE request" do
-      fields = {
-        author: {
-          name: "Winston Smith-Churchill",
-          email: "winston@alphagov.co.uk"
-        }
-      }
-
-      reopen_stub = stub_request(:delete, @base_api_url + "/needs/100001/closed")
-                      .with(body: fields.to_json)
-                      .to_return(status: 204)
-      @api.reopen(100001, fields)
-      assert_requested reopen_stub
-    end
-  end
-
-  describe "creating notes" do
-    it "should send a post request" do
-      fields = {
-        "text" => "test",
-        "need_id" => "100001",
-        "author" => {
-          "name" => "Winston Smith-Churchill",
-          "email" => "winston@alphagov.co.uk"
-        }
-      }
-      request_stub = stub_create_note(fields)
-
-      @api.create_note(fields)
-
-      assert_requested(request_stub)
-    end
-  end
-end