221 - fixed failing test and updated response code converting function

Author: mmacai

docs/api-gateway.md

@@ -212,7 +212,7 @@ Configuration of such API endpoint might look like this:
 - Kinesis -> **not supported**
 - Nats -> `nats`
 
-`http_async` means that correlated response has to be sent to internal `:4010/v2/responses` `POST` endpoint.
+`http_async` means that correlated response has to be sent to internal `:4010/v3/responses` `POST` endpoint.
 
 #### Supported formats
 
@@ -223,9 +223,10 @@ Message headers:
 ```plaintext
 rig-correlation: "correlation_id_sent_by_rig"
 rig-response-code: "201"
+content-type: "application/json"
 ```
 
-> Both headers are required.
+> All headers are required.
 
 Message body:
 

lib/rig_inbound_gateway/api_proxy/handler/http.ex

@@ -118,7 +118,6 @@ defmodule RigInboundGateway.ApiProxy.Handler.Http do
         |> Map.update!(:resp_headers, fn existing_headers ->
           existing_headers ++ Map.to_list(extra_headers)
         end)
-        |> Conn.put_resp_content_type("application/json")
         |> Conn.send_resp(response_code, response)
     after
       response_timeout ->

lib/rig_inbound_gateway/api_proxy/handler/kafka.ex

@@ -271,7 +271,6 @@ defmodule RigInboundGateway.ApiProxy.Handler.Kafka do
         |> Map.update!(:resp_headers, fn existing_headers ->
           existing_headers ++ Map.to_list(extra_headers)
         end)
-        |> Conn.put_resp_content_type("application/json")
         |> Conn.send_resp(response_code, response)
     after
       conf.response_timeout ->

lib/rig_inbound_gateway/api_proxy/response_from_parser.ex

@@ -24,7 +24,7 @@ defmodule RigInboundGateway.ApiProxy.ResponseFromParser do
          # forward extra haeders such as content-type
          extra_headers <- Map.drop(headers_map, ["rig-correlation", "rig-response-code"]),
          # convert status code to int if needed, HTTP headers can't have number as a value
-         response_code <- to_int(raw_response_code),
+         {:ok, response_code} <- to_int(raw_response_code),
          response_body <- try_encode(message) do
       Logger.debug(fn ->
         "Parsed binary HTTP response: body=#{inspect(response_body)}, code=#{
@@ -54,10 +54,10 @@ defmodule RigInboundGateway.ApiProxy.ResponseFromParser do
 
   # ---
 
-  defp to_int(value) when is_integer(value), do: value
+  defp to_int(value) when is_integer(value), do: {:ok, value}
 
   defp to_int(string) when is_binary(string) do
-    String.to_integer(string)
+    {:ok, String.to_integer(string)}
   rescue
     ArgumentError -> {:error, {:not_an_integer, string}}
   end

test/rig_tests/proxy/response_from/async_http_test.exs

@@ -87,8 +87,70 @@ defmodule RigTests.Proxy.ResponseFrom.AsyncHttpTest do
     # ...the connection is closed and the status is OK:
     assert res_status == 201
     # ...extra headers are present
-    assert Enum.member?(headers, {"content-type", "application/json; charset=utf-8"})
+    assert Enum.member?(headers, {"content-type", "application/json;charset=utf-8"})
     # ...but the client got the response sent to the HTTP internal endpoint:
     assert Jason.decode!(res_body) == async_response
   end
+
+  test_with_server "Given response_from is set to http_async and response code is incorrect, the calling service should receive 400 and originating request should timeout." do
+    test_name = "proxy-http-response-from-http-internal-binary-timeout"
+
+    api_id = "mock-#{test_name}-api"
+    endpoint_id = "mock-#{test_name}-endpoint"
+    endpoint_path = "/#{endpoint_id}"
+    sync_response = %{"this response" => "the client never sees this response"}
+    async_response = %{"message" => "this is the async response that reaches the client instead"}
+
+    route(endpoint_path, fn %{query: %{"correlation" => correlation_id}} ->
+      %Plug.Conn{status: res_status, resp_body: res_body} =
+        build_conn()
+        |> put_req_header("rig-correlation", correlation_id)
+        |> put_req_header("rig-response-code", "abc201")
+        |> put_req_header("content-type", "application/json;charset=utf-8")
+        |> post("/v3/responses", Jason.encode!(async_response))
+
+      assert res_status == 400
+      assert res_body == "Failed to parse request body: {:error, {:not_an_integer, \"abc201\"}}"
+
+      Response.ok!(sync_response, %{"content-type" => "application/json"})
+    end)
+
+    # We register the endpoint with the proxy:
+    rig_api_url = "http://localhost:#{@api_port}/v3/apis"
+    rig_proxy_url = "http://localhost:#{@proxy_port}"
+
+    body =
+      Jason.encode!(%{
+        id: api_id,
+        name: "Mock API",
+        version_data: %{
+          default: %{
+            endpoints: [
+              %{
+                id: endpoint_id,
+                method: "GET",
+                path: endpoint_path,
+                response_from: "http_async"
+              }
+            ]
+          }
+        },
+        proxy: %{
+          target_url: "localhost",
+          port: FakeServer.port()
+        }
+      })
+
+    headers = [{"content-type", "application/json"}]
+    HTTPoison.post!(rig_api_url, body, headers)
+
+    # The client calls the proxy endpoint:
+    request_url = rig_proxy_url <> endpoint_path
+
+    assert catch_error(HTTPoison.get!(request_url)) == %HTTPoison.Error{id: nil, reason: :timeout}
+
+    # Now we can assert that...
+    # ...the fake backend service has been called:
+    assert FakeServer.hits() == 1
+  end
 end