gds-api-adapters 38.1.0 → 39.0.0

data/test/organisations_api_test.rb

@@ -1,58 +0,0 @@
-require_relative 'test_helper'
-require 'gds_api/organisations'
-require 'gds_api/test_helpers/organisations'
-
-describe GdsApi::Organisations do
-  include GdsApi::TestHelpers::Organisations
-
-  before do
-    @base_api_url = GdsApi::TestHelpers::Organisations::ORGANISATIONS_API_ENDPOINT
-    @api = GdsApi::Organisations.new(@base_api_url)
-  end
-
-  describe "fetching list of organisations" do
-    it "should get the organisations" do
-      organisation_slugs = %w(ministry-of-fun, tea-agency)
-      organisations_api_has_organisations(organisation_slugs)
-
-      response = @api.organisations
-      assert_equal organisation_slugs, response.map { |r| r['details']['slug'] }
-      assert_equal "Tea Agency", response['results'][1]['title']
-    end
-
-    it "should handle the pagination" do
-      organisation_slugs = (1..50).map { |n| "organisation-#{n}" }
-      organisations_api_has_organisations(organisation_slugs)
-
-      response = @api.organisations
-      assert_equal(
-        organisation_slugs,
-        response.with_subsequent_pages.map { |r| r['details']['slug'] }
-      )
-    end
-
-    it "should raise error if endpoint 404s" do
-      stub_request(:get, "#{@base_api_url}/api/organisations").to_return(status: 404)
-      assert_raises GdsApi::HTTPNotFound do
-        @api.organisations
-      end
-    end
-  end
-
-  describe "fetching an organisation" do
-    it "should return the details" do
-      organisations_api_has_organisation('ministry-of-fun')
-
-      response = @api.organisation('ministry-of-fun')
-      assert_equal 'Ministry Of Fun', response['title']
-    end
-
-    it "should raise for a non-existent organisation" do
-      organisations_api_does_not_have_organisation('non-existent')
-
-      assert_raises(GdsApi::HTTPNotFound) do
-        @api.organisation('non-existent')
-      end
-    end
-  end
-end

data/test/panopticon_registerer_test.rb

@@ -1,118 +0,0 @@
-require_relative 'test_helper'
-require 'gds_api/panopticon'
-require 'gds_api/test_helpers/panopticon'
-require 'ostruct'
-
-describe GdsApi::Panopticon::Registerer do
-  include GdsApi::TestHelpers::Panopticon
-
-  describe "creating an instance of the panopticon client" do
-    describe "setting the platform" 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)
-        r = GdsApi::Panopticon::Registerer.new({})
-        assert_equal :panopticon_instance, r.send(:panopticon)
-      end
-
-      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")
-        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)
-        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)
-        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)
-        r = GdsApi::Panopticon::Registerer.new({})
-        assert_equal :panopticon_instance, r.send(:panopticon)
-      end
-    end
-
-    it "should memoize the panopticon instance" do
-      GdsApi::Panopticon.expects(:new).once.returns(:panopticon_instance)
-      r = GdsApi::Panopticon::Registerer.new({})
-
-      assert_equal :panopticon_instance, r.send(:panopticon)
-      assert_equal :panopticon_instance, r.send(:panopticon)
-    end
-  end
-
-  it "should register artefacts" do
-    request = stub_artefact_registration('beards',
-      slug: 'beards',
-      owning_app: 'whitehall',
-      kind: 'detailed-guide',
-      name: 'A guide to beards',
-      description: '5 tips for keeping your beard in check',
-      state: 'draft',
-      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'
-    )
-
-    GdsApi::Panopticon::Registerer.new(
-      owning_app: 'whitehall',
-      kind: 'detailed-guide'
-    ).register(
-      OpenStruct.new(
-        slug: 'beards',
-        title: 'A guide to beards',
-        description: '5 tips for keeping your beard in check',
-        state: 'draft',
-        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"],
-        public_timestamp: DateTime.parse('2014-01-01 12:00:00 +00:00'),
-        latest_change_note: 'Added more stubble',
-        content_id: 'f47b4fab-46fa-4020-97a2-3413a5d75402'
-      )
-    )
-
-    assert_requested(request)
-  end
-
-  it "should support deprecated fields" do
-    request = stub_artefact_registration('beards',
-      slug: 'beards',
-      owning_app: 'whitehall',
-      kind: 'detailed-guide',
-      name: 'A guide to beards',
-      description: '5 tips for keeping your beard in check',
-      state: 'draft',
-    )
-
-    GdsApi::Panopticon::Registerer.new(
-      owning_app: 'whitehall',
-      kind: 'detailed-guide'
-    ).register(
-      OpenStruct.new(
-        slug: 'beards',
-        title: 'A guide to beards',
-        description: '5 tips for keeping your beard in check',
-        state: 'draft',
-      )
-    )
-
-    assert_requested(request)
-  end
-end

data/test/panopticon_test.rb

@@ -1,190 +0,0 @@
-require 'test_helper'
-require 'gds_api/panopticon'
-require 'gds_api/test_helpers/panopticon'
-
-describe GdsApi::Panopticon do
-  include GdsApi::TestHelpers::Panopticon
-
-  let(:base_api_endpoint) { GdsApi::TestHelpers::Panopticon::PANOPTICON_ENDPOINT }
-  let(:api) { GdsApi::Panopticon.new(base_api_endpoint) }
-
-  let(:basic_artefact) {
-    {
-      name: 'An artefact',
-      slug: 'a-basic-artefact'
-    }
-  }
-  let(:artefact_with_contact) {
-    {
-      name: 'An artefact',
-      slug: 'an-artefact-with-contact',
-      contact: {
-        name: 'Department for Environment, Food and Rural Affairs (Defra)',
-        email_address: 'helpline@defra.gsi.gov.uk'
-      }
-    }
-  }
-  let(:registerable_artefact) {
-    {
-      slug: 'foo',
-      owning_app: 'my-app',
-      kind: 'custom-application',
-      name: 'MyFoo',
-      description: 'A custom foo of great customness.',
-      state: 'live'
-    }
-  }
-
-  it 'fetches an artefact given a slug' do
-    panopticon_has_metadata(basic_artefact)
-
-    artefact = api.artefact_for_slug(basic_artefact[:slug])
-    assert_equal 'An artefact', artefact['name']
-  end
-
-  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)
-    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)
-
-    assert_equal 1, api.get_json(url)['a']
-  end
-
-  it 'raises if the endpoint returns 404' do
-    url = "#{base_api_endpoint}/some.json"
-    stub_request(:get, url).to_return(status: Rack::Utils.status_code(:not_found))
-
-    assert_raises(GdsApi::HTTPNotFound) do
-      api.get_json(url)
-    end
-  end
-
-  it 'constructs the correct URL for a slug' do
-    assert_equal "#{base_api_endpoint}/artefacts/slug.json", api.url_for_slug('slug')
-  end
-
-  it 'deserialises contacts into whole objects' do
-    panopticon_has_metadata(artefact_with_contact)
-
-    artefact = api.artefact_for_slug(artefact_with_contact[:slug])
-    assert_equal(
-      'Department for Environment, Food and Rural Affairs (Defra)',
-      artefact['contact']['name']
-    )
-    assert_equal(
-      'helpline@defra.gsi.gov.uk',
-      artefact['contact']['email_address']
-    )
-  end
-
-  it 'creates a new artefact' do
-    url = "#{base_api_endpoint}/artefacts.json"
-    stub_request(:post, url)
-      .with(body: basic_artefact.to_json)
-      .to_return(body: basic_artefact.merge(id: 1).to_json)
-
-    api.create_artefact(basic_artefact)
-  end
-
-  it 'updates an existing artefact' do
-    url = "#{base_api_endpoint}/artefacts/1.json"
-    stub_request(:put, url)
-      .with(body: basic_artefact.to_json)
-      .to_return(status: 200, body: '{}')
-
-    api.update_artefact(1, basic_artefact)
-  end
-
-  it 'deletes an artefact' do
-    url = "#{base_api_endpoint}/artefacts/1.json"
-    stub_request(:delete, url)
-      .with(body: "")
-      .to_return(status: 200, body: '{}')
-
-    api.delete_artefact!(1)
-  end
-
-  it 'uses basic auth' do
-    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)
-      .to_return(status: 200, body: '{}')
-
-    api.update_artefact(1, basic_artefact)
-  end
-
-  it 'registers new artefacts en masse' do
-    r = GdsApi::Panopticon::Registerer.new(endpoint_url: base_api_endpoint, owning_app: 'my-app')
-    artefact = registerable_artefact
-    panopticon_has_no_metadata_for('foo')
-
-    stub_request(:put, "#{base_api_endpoint}/artefacts/foo.json")
-      .with(body: artefact.to_json)
-      .to_return(body: artefact.merge(id: 1).to_json)
-
-    url = "#{base_api_endpoint}/artefacts.json"
-    stub_request(:post, url)
-      .with(body: artefact.to_json)
-      .to_return(body: artefact.merge(id: 1).to_json)
-
-    record = OpenStruct.new(artefact.merge(title: artefact[:name]))
-    r.register(record)
-  end
-
-  it 'registers existing artefacts en masse' do
-    artefact = registerable_artefact
-    r = GdsApi::Panopticon::Registerer.new(endpoint_url: base_api_endpoint, owning_app: 'my-app')
-
-    panopticon_has_metadata(artefact)
-    url = "#{base_api_endpoint}/artefacts/foo.json"
-    stub_request(:put, url)
-      .with(body: artefact.to_json)
-      .to_return(status: 200, body: '{}')
-
-    record = OpenStruct.new(artefact.merge(title: artefact[:name]))
-    r.register(record)
-  end
-
-  describe 'tags' do
-    let(:tag) {
-      { tag_type: 'section', tag_id: 'housing', title: 'Housing', description: 'Housing', parent_id: nil }
-    }
-
-    it 'creates a tag' do
-      url = "#{base_api_endpoint}/tags.json"
-      req = stub_request(:post, url)
-              .with(body: tag.to_json)
-              .to_return(status: 201, body: tag.to_json)
-
-      api.create_tag(tag)
-      assert_requested(req)
-    end
-
-    it 'updates a tag' do
-      url = "#{base_api_endpoint}/tags/section/citizenship/passports.json"
-      fields_to_update = { title: 'Passports' }
-
-      req = stub_request(:put, url)
-              .with(body: fields_to_update.to_json)
-              .to_return(status: 200)
-
-      api.put_tag('section', 'citizenship/passports', fields_to_update)
-      assert_requested(req)
-    end
-
-    it 'publishes a tag' do
-      url = "#{base_api_endpoint}/tags/section/citizenship/passports/publish.json"
-      req = stub_request(:post, url).with(body: {}.to_json)
-                                    .to_return(status: 200)
-
-      api.publish_tag('section', 'citizenship/passports')
-      assert_requested(req)
-    end
-  end
-end

data/test/pp_data_in_test.rb

@@ -1,52 +0,0 @@
-require 'test_helper'
-require 'gds_api/performance_platform/data_in'
-require 'gds_api/test_helpers/performance_platform/data_in'
-
-describe GdsApi::PerformancePlatform::DataIn do
-  include GdsApi::TestHelpers::PerformancePlatform::DataIn
-
-  before do
-    @base_api_url = GdsApi::TestHelpers::PerformancePlatform::DataIn::PP_DATA_IN_ENDPOINT
-    @api = GdsApi::PerformancePlatform::DataIn.new(@base_api_url)
-  end
-
-  it "can submit a day aggregate for service feedback for a particular slug" do
-    request_details = { "some" => "data" }
-
-    stub_post = stub_service_feedback_day_aggregate_submission("some-slug", request_details)
-
-    @api.submit_service_feedback_day_aggregate("some-slug", request_details)
-
-    assert_requested(stub_post)
-  end
-
-  it "can submit entries counts for corporate content problem reports" do
-    entries = %w(some entries)
-
-    stub_post = stub_corporate_content_problem_report_count_submission(entries)
-
-    @api.corporate_content_problem_report_count(entries)
-
-    assert_requested(stub_post)
-  end
-
-  it "can submit the corporate content urls with the most problem reports" do
-    entries = %w(some entries)
-
-    stub_post = stub_corporate_content_urls_with_the_most_problem_reports_submission(entries)
-
-    @api.corporate_content_urls_with_the_most_problem_reports(entries)
-
-    assert_requested(stub_post)
-  end
-
-  it "throws an exception when the support app isn't available" do
-    stub_pp_isnt_available
-    assert_raises(GdsApi::HTTPServerError) { @api.submit_service_feedback_day_aggregate("doesnt_matter", {}) }
-  end
-
-  it "throws an exception when the the bucket for that slug hasn't been defined" do
-    stub_service_feedback_bucket_unavailable_for("some_transaction")
-    assert_raises(GdsApi::PerformancePlatformDatasetNotConfigured) { @api.submit_service_feedback_day_aggregate("some_transaction", {}) }
-  end
-end

data/test/pp_data_out_test.rb

@@ -1,24 +0,0 @@
-require 'test_helper'
-require 'gds_api/performance_platform/data_out'
-require 'gds_api/test_helpers/performance_platform/data_out'
-
-describe GdsApi::PerformancePlatform::DataOut do
-  include GdsApi::TestHelpers::PerformancePlatform::DataOut
-
-  before do
-    @base_api_url = GdsApi::TestHelpers::PerformancePlatform::DataOut::PP_DATA_OUT_ENDPOINT
-    @api = GdsApi::PerformancePlatform::DataOut.new(@base_api_url)
-  end
-
-  let(:transaction_slug) { 'register-to-vote' }
-
-  it "calls the service feedback endpoint for a particular slug" do
-    request_details = { "some" => "data" }
-
-    stub_post = stub_service_feedback(transaction_slug, request_details)
-
-    @api.service_feedback(transaction_slug)
-
-    assert_requested(stub_post)
-  end
-end

data/test/publishing_api/special_route_publisher_test.rb

@@ -1,104 +0,0 @@
-require 'test_helper'
-require "gds_api/publishing_api/special_route_publisher"
-require File.dirname(__FILE__) + '/../../lib/gds_api/test_helpers/publishing_api_v2'
-
-describe GdsApi::PublishingApi::SpecialRoutePublisher do
-  include ::GdsApi::TestHelpers::PublishingApiV2
-
-  let(:content_id) { 'a-content-id-of-sorts' }
-  let(:special_route) {
-    {
-      content_id: content_id,
-      title: "A title",
-      description: "A description",
-      base_path: "/favicon.ico",
-      type: "exact",
-      publishing_app: "static-publisher",
-      rendering_app: "static-frontend",
-    }
-  }
-
-  let(:publisher) { GdsApi::PublishingApi::SpecialRoutePublisher.new }
-  let(:endpoint) { Plek.current.find('publishing-api') }
-
-  describe ".publish" do
-    before do
-      stub_any_publishing_api_call
-    end
-
-    it "publishes the special routes" do
-      Timecop.freeze(Time.now) do
-        publisher.publish(special_route)
-
-        expected_payload = {
-          base_path: special_route[:base_path],
-          document_type: "special_route",
-          schema_name: "special_route",
-          title: special_route[:title],
-          description: special_route[:description],
-          routes: [
-            {
-              path: special_route[:base_path],
-              type: special_route[:type],
-            }
-          ],
-          publishing_app: special_route[:publishing_app],
-          rendering_app: special_route[:rendering_app],
-          public_updated_at: Time.now.iso8601,
-        }
-
-        assert_requested(:put, "#{endpoint}/v2/content/#{content_id}", body: expected_payload)
-        assert_publishing_api_publish(content_id, update_type: 'major')
-      end
-    end
-
-    it "publishes links" do
-      links = {
-        links: {
-          organisations: ['org-content-id']
-        }
-      }
-
-      publisher.publish(special_route.merge(links))
-
-      assert_requested(:patch, "#{endpoint}/v2/links/#{content_id}", body: links)
-    end
-
-    describe 'Timezone handling' do
-      let(:publishing_api) {
-        stub(:publishing_api, put_content_item: nil)
-      }
-      let(:publisher) {
-        GdsApi::PublishingApi::SpecialRoutePublisher.new(publishing_api: publishing_api)
-      }
-
-      it "is robust to Time.zone returning nil" do
-        Timecop.freeze(Time.now) do
-          Time.stubs(:zone).returns(nil)
-          publishing_api.expects(:put_content).with(
-            anything,
-            has_entries(public_updated_at: Time.now.iso8601)
-          )
-          publishing_api.expects(:publish)
-
-          publisher.publish(special_route)
-        end
-      end
-
-      it "uses Time.zone if available" do
-        Timecop.freeze(Time.now) do
-          time_in_zone = stub("Time in zone", now: Time.parse("2010-01-01 10:10:10 +04:00"))
-          Time.stubs(:zone).returns(time_in_zone)
-
-          publishing_api.expects(:put_content).with(
-            anything,
-            has_entries(public_updated_at: time_in_zone.now.iso8601)
-          )
-          publishing_api.expects(:publish)
-
-          publisher.publish(special_route)
-        end
-      end
-    end
-  end
-end