gds-api-adapters 38.1.0 → 39.0.0

data/test/response_test.rb

@@ -1,245 +0,0 @@
-require_relative 'test_helper'
-require 'gds_api/response'
-
-describe GdsApi::Response do
-  describe "accessing HTTP response details" do
-    before :each do
-      @mock_http_response = stub(body: "A Response body", code: 200, headers: { cache_control: 'public' })
-      @response = GdsApi::Response.new(@mock_http_response)
-    end
-
-    it "should return the raw response body" do
-      assert_equal "A Response body", @response.raw_response_body
-    end
-
-    it "should return the status code" do
-      assert_equal 200, @response.code
-    end
-
-    it "should pass-on the response headers" do
-      assert_equal({ cache_control: 'public' }, @response.headers)
-    end
-  end
-
-  describe ".expires_at" do
-    it "should be calculated from cache-control max-age" do
-      Timecop.freeze(Time.parse("15:00")) do
-        cache_control_headers = { cache_control: 'public, max-age=900' }
-        headers = cache_control_headers.merge(date: Time.now.httpdate)
-
-        mock_http_response = stub(body: "A Response body", code: 200, headers: headers)
-        response = GdsApi::Response.new(mock_http_response)
-
-        assert_equal Time.parse("15:15"), response.expires_at
-      end
-    end
-
-    it "should be same as the value of Expires header in absence of max-age" do
-      Timecop.freeze(Time.parse("15:00")) do
-        cache_headers = { cache_control: 'public', expires: (Time.now + 900).httpdate }
-        headers = cache_headers.merge(date: Time.now.httpdate)
-
-        mock_http_response = stub(body: "A Response body", code: 200, headers: headers)
-        response = GdsApi::Response.new(mock_http_response)
-
-        assert_equal Time.parse("15:15"), response.expires_at
-      end
-    end
-
-    it "should be nil in absence of Expires header and max-age" do
-      mock_http_response = stub(body: "A Response body", code: 200, headers: { date: Time.now.httpdate })
-      response = GdsApi::Response.new(mock_http_response)
-
-      assert_nil response.expires_at
-    end
-
-    it "should be nil in absence of Date header and max-age" do
-      mock_http_response = stub(body: "A Response body", code: 200, headers: {})
-      response = GdsApi::Response.new(mock_http_response)
-
-      assert_nil response.expires_at
-    end
-  end
-
-  describe ".expires_in" do
-    it "should be seconds remaining from expiration time inferred from max-age" do
-      cache_control_headers = { cache_control: 'public, max-age=900' }
-      headers = cache_control_headers.merge(date: Time.now.httpdate)
-      mock_http_response = stub(body: "A Response body", code: 200, headers: headers)
-
-      Timecop.travel(12 * 60) do
-        response = GdsApi::Response.new(mock_http_response)
-        assert_equal 180, response.expires_in
-      end
-    end
-
-    it "should be seconds remaining from expiration time inferred from Expires header" do
-      cache_headers = { cache_control: 'public', expires: (Time.now + 900).httpdate }
-      headers = cache_headers.merge(date: Time.now.httpdate)
-      mock_http_response = stub(body: "A Response body", code: 200, headers: headers)
-
-      Timecop.travel(12 * 60) do
-        response = GdsApi::Response.new(mock_http_response)
-        assert_equal 180, response.expires_in
-      end
-    end
-
-    it "should be nil in absence of Expires header and max-age" do
-      mock_http_response = stub(body: "A Response body", code: 200, headers: { date: Time.now.httpdate })
-      response = GdsApi::Response.new(mock_http_response)
-
-      assert_nil response.expires_in
-    end
-
-    it "should be nil in absence of Date header" do
-      cache_control_headers = { cache_control: 'public, max-age=900' }
-      mock_http_response = stub(body: "A Response body", code: 200, headers: cache_control_headers)
-      response = GdsApi::Response.new(mock_http_response)
-
-      assert_nil response.expires_in
-    end
-  end
-
-  describe "processing web_urls" do
-    def build_response(body_string, relative_to = "https://www.gov.uk")
-      GdsApi::Response.new(stub(body: body_string), web_urls_relative_to: relative_to)
-    end
-
-    it "should map web URLs" do
-      body = {
-        "web_url" => "https://www.gov.uk/test"
-      }.to_json
-      assert_equal "/test", build_response(body)['web_url']
-    end
-
-    it "should leave other properties alone" do
-      body = {
-        "title" => "Title",
-        "description" => "Description"
-      }.to_json
-      response = build_response(body)
-      assert_equal "Title", response['title']
-      assert_equal "Description", response['description']
-    end
-
-    it "should traverse into hashes" do
-      body = {
-        "details" => {
-          "chirality" => "widdershins",
-          "web_url" => "https://www.gov.uk/left",
-        }
-      }.to_json
-
-      response = build_response(body)
-      assert_equal "/left", response['details']['web_url']
-    end
-
-    it "should traverse into arrays" do
-      body = {
-        "other_urls" => [
-          { "title" => "Pies", "web_url" => "https://www.gov.uk/pies" },
-          { "title" => "Cheese", "web_url" => "https://www.gov.uk/cheese" },
-        ]
-      }.to_json
-
-      response = build_response(body)
-      assert_equal "/pies", response['other_urls'][0]['web_url']
-      assert_equal "/cheese", response['other_urls'][1]['web_url']
-    end
-
-    it "should handle nil values" do
-      body = { "web_url" => nil }.to_json
-
-      response = build_response(body)
-      assert_nil response['web_url']
-    end
-
-    it "should handle query parameters" do
-      body = {
-        "web_url" => "https://www.gov.uk/thing?does=stuff"
-      }.to_json
-
-      response = build_response(body)
-      assert_equal "/thing?does=stuff", response['web_url']
-    end
-
-    it "should handle fragments" do
-      body = {
-        "web_url" => "https://www.gov.uk/thing#part-2"
-      }.to_json
-
-      response = build_response(body)
-      assert_equal "/thing#part-2", response['web_url']
-    end
-
-    it "should keep URLs from other domains absolute" do
-      body = {
-        "web_url" => "https://www.example.com/example"
-      }.to_json
-
-      response = build_response(body)
-      assert_equal "https://www.example.com/example", response['web_url']
-    end
-
-    it "should keep URLs with other schemes absolute" do
-      body = {
-        "web_url" => "http://www.example.com/example"
-      }.to_json
-
-      response = build_response(body)
-      assert_equal "http://www.example.com/example", response['web_url']
-    end
-  end
-
-  describe "hash and openstruct access" do
-    before :each do
-      @response_data = {
-        "_response_info" => {
-            "status" => "ok"
-        },
-        "id" => "https://www.gov.uk/api/vat-rates.json",
-        "web_url" => "https://www.gov.uk/vat-rates",
-        "title" => "VAT rates",
-        "format" => "answer",
-        "updated_at" => "2013-04-04T15:51:54+01:00",
-        "details" => {
-            "need_id" => "1870",
-            "business_proposition" => false,
-            "description" => "Current VAT rates - standard 20% and rates for reduced rate and zero-rated items",
-            "language" => "en",
-        },
-        "tags" => [
-          { "slug" => "foo" },
-          { "slug" => "bar" },
-          { "slug" => "baz" },
-        ],
-      }
-      @response = GdsApi::Response.new(stub(body: @response_data.to_json))
-    end
-
-    describe "behaving like a read-only hash" do
-      it "should allow accessing members by key" do
-        assert_equal "VAT rates", @response["title"]
-      end
-
-      it "should allow accessing nested keys" do
-        assert_equal "1870", @response["details"]["need_id"]
-      end
-
-      it "should return nil for a non-existent key" do
-        assert_equal nil, @response["foo"]
-      end
-
-      it "should memoize the parsed hash" do
-        @response["id"]
-        JSON.expects(:parse).never
-        assert_equal "VAT rates", @response["title"]
-      end
-
-      it "should allow using dig to access nested keys" do
-        skip unless RUBY_VERSION > "2.3"
-        assert_equal "1870", @response.dig("details", "need_id")
-      end
-    end
-  end
-end

data/test/router_test.rb

@@ -1,456 +0,0 @@
-require 'test_helper'
-require 'gds_api/router'
-
-describe GdsApi::Router do
-  before do
-    @base_api_url = "http://router-api.example.com"
-    @api = GdsApi::Router.new(@base_api_url)
-  end
-
-  describe "managing backends" do
-    describe "fetching details about a backend" do
-      it "should return backend details" do
-        req = WebMock.stub_request(:get, "#{@base_api_url}/backends/foo").
-          to_return(body: { "backend_id" => "foo", "backend_url" => "http://foo.example.com/" }.to_json,
-                    headers: { "Content-type" => "application/json" })
-
-        response = @api.get_backend("foo")
-        assert_equal 200, response.code
-        assert_equal "http://foo.example.com/", response['backend_url']
-
-        assert_requested(req)
-      end
-
-      it "raises for a non-existend backend" do
-        req = WebMock.stub_request(:get, "#{@base_api_url}/backends/foo").
-          to_return(status: 404)
-
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api.get_backend("foo")
-        end
-
-        assert_requested(req)
-      end
-
-      it "should URI escape the given ID" do
-        req = WebMock.stub_request(:get, "#{@base_api_url}/backends/foo+bar").
-          to_return(status: 404)
-
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api.get_backend("foo bar")
-        end
-
-        assert_requested(req)
-      end
-    end
-
-    describe "creating/updating a backend" do
-      it "should allow creating/updating a backend" do
-        req = WebMock.stub_request(:put, "#{@base_api_url}/backends/foo").
-          with(body: { "backend" => { "backend_url" => "http://foo.example.com/" } }.to_json).
-          to_return(status: 201, body: { "backend_id" => "foo", "backend_url" => "http://foo.example.com/" }.to_json,
-                    headers: { "Content-type" => "application/json" })
-
-        response = @api.add_backend("foo", "http://foo.example.com/")
-        assert_equal 201, response.code
-        assert_equal "http://foo.example.com/", response['backend_url']
-
-        assert_requested(req)
-      end
-
-      it "should raise an error if creating/updating a backend fails" do
-        response_data = { "backend_id" => "foo", "backend_url" => "ftp://foo.example.com/", "errors" => { "backend_url" => "is not an HTTP URL" } }
-        req = WebMock.stub_request(:put, "#{@base_api_url}/backends/foo").
-          with(body: { "backend" => { "backend_url" => "http://foo.example.com/" } }.to_json).
-          to_return(status: 400, body: response_data.to_json, headers: { "Content-type" => "application/json" })
-
-        e = nil
-        begin
-          @api.add_backend("foo", "http://foo.example.com/")
-        rescue GdsApi::HTTPErrorResponse => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 400, e.code
-        assert_equal response_data, e.error_details
-
-        assert_requested(req)
-      end
-
-      it "should URI escape the passed id" do
-        req = WebMock.stub_request(:put, "#{@base_api_url}/backends/foo+bar").
-          with(body: { "backend" => { "backend_url" => "http://foo.example.com/" } }.to_json).
-          to_return(status: 404, body: "Not found")
-
-        # We expect a GdsApi::HTTPErrorResponse, but we want to ensure nothing else is raised
-        begin
-          @api.add_backend("foo bar", "http://foo.example.com/")
-        rescue GdsApi::HTTPErrorResponse
-          nil
-        end
-
-        assert_requested(req)
-      end
-    end
-
-    describe "deleting a backend" do
-      it "allow deleting a backend" do
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/backends/foo").
-          to_return(status: 200, body: { "backend_id" => "foo", "backend_url" => "http://foo.example.com/" }.to_json,
-                    headers: { "Content-type" => "application/json" })
-
-        response = @api.delete_backend("foo")
-        assert_equal 200, response.code
-        assert_equal "http://foo.example.com/", response['backend_url']
-
-        assert_requested(req)
-      end
-
-      it "should raise an error if deleting the backend fails" do
-        response_data = { "backend_id" => "foo", "backend_url" => "ftp://foo.example.com/", "errors" => { "base" => "Backend has routes - can't delete" } }
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/backends/foo").
-          to_return(status: 400, body: response_data.to_json, headers: { "Content-type" => "application/json" })
-
-        e = nil
-        begin
-          @api.delete_backend("foo")
-        rescue GdsApi::HTTPErrorResponse => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 400, e.code
-        assert_equal response_data, e.error_details
-
-        assert_requested(req)
-      end
-
-      it "should URI escape the passed id" do
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/backends/foo+bar").
-          to_return(status: 404, body: "Not found")
-
-        # We expect a GdsApi::HTTPErrorResponse, but we want to ensure nothing else is raised
-        assert_raises GdsApi::HTTPErrorResponse do
-          @api.delete_backend("foo bar")
-        end
-
-        assert_requested(req)
-      end
-    end
-  end
-
-  describe "managing routes" do
-    before :each do
-      @commit_req = WebMock.stub_request(:post, "#{@base_api_url}/routes/commit").
-        to_return(status: 200, body: "Routers updated")
-    end
-
-    describe "fetching a route" do
-      it "should return the route details" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "backend", "backend_id" => "foo" }
-        req = WebMock.stub_request(:get, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo" }).
-          to_return(status: 200, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.get_route("/foo")
-        assert_equal 200, response.code
-        assert_equal "foo", response['backend_id']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should raise if nothing found" do
-        req = WebMock.stub_request(:get, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo" }).
-          to_return(status: 404)
-
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api.get_route("/foo")
-        end
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should escape the params" do
-        # The WebMock query matcher matches unescaped params.  The call blows up if they're not escaped
-
-        req = WebMock.stub_request(:get, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo bar" }).
-          to_return(status: 404)
-
-        assert_raises(GdsApi::HTTPNotFound) do
-          @api.get_route("/foo bar")
-        end
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-    end
-
-    describe "creating/updating a route" do
-      it "should allow creating/updating a route" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "backend", "backend_id" => "foo" }
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 201, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.add_route("/foo", "exact", "foo")
-        assert_equal 201, response.code
-        assert_equal "foo", response['backend_id']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should commit the routes when asked to" do
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          to_return(status: 201, body: {}.to_json, headers: { "Content-type" => "application/json" })
-
-        @api.add_route("/foo", "exact", "foo", commit: true)
-
-        assert_requested(req)
-        assert_requested(@commit_req)
-      end
-
-      it "should raise an error if creating/updating the route fails" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "backend", "backend_id" => "foo" }
-        response_data = route_data.merge("errors" => { "backend_id" => "does not exist" })
-
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 400, body: response_data.to_json, headers: { "Content-type" => "application/json" })
-
-        e = nil
-        begin
-          @api.add_route("/foo", "exact", "foo")
-        rescue GdsApi::HTTPErrorResponse => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 400, e.code
-        assert_equal response_data, e.error_details
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-    end
-
-    describe "creating/updating a redirect route" do
-      it "should allow creating/updating a redirect route" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "redirect",
-          "redirect_to" => "/bar", "redirect_type" => "permanent", "segments_mode" => nil }
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 201, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.add_redirect_route("/foo", "exact", "/bar")
-        assert_equal 201, response.code
-        assert_equal "/bar", response['redirect_to']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should allow creating/updating a temporary redirect route" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "redirect",
-          "redirect_to" => "/bar", "redirect_type" => "temporary", "segments_mode" => nil }
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 201, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.add_redirect_route("/foo", "exact", "/bar", "temporary")
-        assert_equal 201, response.code
-        assert_equal "/bar", response['redirect_to']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should allow creating/updating a redirect route which preserves segments" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "redirect",
-          "redirect_to" => "/bar", "redirect_type" => "temporary", "segments_mode" => "preserve" }
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 201, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.add_redirect_route("/foo", "exact", "/bar", "temporary", segments_mode: "preserve")
-        assert_equal 201, response.code
-        assert_equal "/bar", response['redirect_to']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should commit the routes when asked to" do
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          to_return(status: 201, body: {}.to_json, headers: { "Content-type" => "application/json" })
-
-        @api.add_redirect_route("/foo", "exact", "/bar", "temporary", commit: true)
-
-        assert_requested(req)
-        assert_requested(@commit_req)
-      end
-
-      it "should raise an error if creating/updating the redirect route fails" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "redirect",
-          "redirect_to" => "bar", "redirect_type" => "permanent", "segments_mode" => nil }
-        response_data = route_data.merge("errors" => { "redirect_to" => "is not a valid URL path" })
-
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 400, body: response_data.to_json, headers: { "Content-type" => "application/json" })
-
-        e = nil
-        begin
-          @api.add_redirect_route("/foo", "exact", "bar")
-        rescue GdsApi::HTTPErrorResponse => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 400, e.code
-        assert_equal response_data, e.error_details
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-    end
-
-    describe "#add_gone_route" do
-      it "should allow creating/updating a gone route" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "gone" }
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 201, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.add_gone_route("/foo", "exact")
-        assert_equal 201, response.code
-        assert_equal "/foo", response['incoming_path']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should commit the routes when asked to" do
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          to_return(status: 201, body: {}.to_json, headers: { "Content-type" => "application/json" })
-
-        @api.add_gone_route("/foo", "exact", commit: true)
-
-        assert_requested(req)
-        assert_requested(@commit_req)
-      end
-
-      it "should raise an error if creating/updating the gone route fails" do
-        route_data = { "incoming_path" => "foo", "route_type" => "exact", "handler" => "gone" }
-        response_data = route_data.merge("errors" => { "incoming_path" => "is not a valid URL path" })
-
-        req = WebMock.stub_request(:put, "#{@base_api_url}/routes").
-          with(body: { "route" => route_data }.to_json).
-          to_return(status: 400, body: response_data.to_json, headers: { "Content-type" => "application/json" })
-
-        e = nil
-        begin
-          @api.add_gone_route("foo", "exact")
-        rescue GdsApi::HTTPErrorResponse => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 400, e.code
-        assert_equal response_data, e.error_details
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-    end
-
-    describe "deleting a route" do
-      it "should allow deleting a route" do
-        route_data = { "incoming_path" => "/foo", "route_type" => "exact", "handler" => "backend", "backend_id" => "foo" }
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo" }).
-          to_return(status: 200, body: route_data.to_json, headers: { "Content-type" => "application/json" })
-
-        response = @api.delete_route("/foo")
-        assert_equal 200, response.code
-        assert_equal "foo", response['backend_id']
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should commit the routes when asked to" do
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo" }).
-          to_return(status: 200, body: {}.to_json, headers: { "Content-type" => "application/json" })
-
-        @api.delete_route("/foo", commit: true)
-
-        assert_requested(req)
-        assert_requested(@commit_req)
-      end
-
-      it "should raise HTTPNotFound if nothing found" do
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo" }).
-          to_return(status: 404)
-
-        e = nil
-        begin
-          @api.delete_route("/foo")
-        rescue GdsApi::HTTPNotFound => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 404, e.code
-
-        assert_requested(req)
-        assert_not_requested(@commit_req)
-      end
-
-      it "should escape the params" do
-        # The WebMock query matcher matches unescaped params.  The call blows up if they're not escaped
-
-        req = WebMock.stub_request(:delete, "#{@base_api_url}/routes").
-          with(query: { "incoming_path" => "/foo bar" }).
-          to_return(status: 404)
-
-        assert_raises GdsApi::HTTPNotFound do
-          @api.delete_route("/foo bar")
-        end
-
-        assert_requested(req)
-      end
-    end
-
-    describe "committing the routes" do
-      it "should allow committing the routes" do
-        @api.commit_routes
-
-        assert_requested(@commit_req)
-      end
-
-      it "should raise an error if committing the routes fails" do
-        WebMock.stub_request(:post, "#{@base_api_url}/routes/commit").
-          to_return(status: 500, body: "Failed to update all routers")
-
-        e = nil
-        begin
-          @api.commit_routes
-        rescue GdsApi::HTTPErrorResponse => ex
-          e = ex
-        end
-
-        refute_nil e
-        assert_equal 500, e.code
-        assert_equal "URL: #{@base_api_url}/routes/commit\nResponse body:\nFailed to update all routers\n\nRequest body:\n{}", e.message
-      end
-    end
-  end
-end