Parse HTTP headers

Author: fornwall

src/index.ts

@@ -28,22 +28,72 @@ export enum HttpProtocol {
   HTTPS
 }
 
+/** HTTP request or response headers. */
+export class HttpHeaders {
+  private headers: Map<string, string[]>;
+
+  constructor(headers?: { [name: string]: string | string[] }) {
+    if (headers) {
+      this.headers = new Map<string, string[]>();
+      Object.keys(headers).forEach(headerName => {
+        let values: string | string[] = headers[headerName];
+        if (typeof values === "string") {
+          values = [values];
+        }
+        if (values.length > 0) {
+          this.headers.set(headerName.toLowerCase(), values);
+        }
+      });
+    } else {
+      this.headers = new Map<string, string[]>();
+    }
+  }
+
+  /**
+   * The first header value for the given header name, if any.
+   *
+   * @param headerName Header name.
+   *
+   * @returns The first header value, or null if none.
+   * @see #getAll
+   */
+  get(headerName: string): string | null {
+    const values = this.headers.get(headerName.toLowerCase());
+    return values && values.length > 0 ? values[0] : null;
+  }
+
+  /**
+   * All header values for the given header name.
+   *
+   * @param headerName The header name.
+   *
+   * @returns an immutable list of header values, or an empty list if none
+   * @see #get
+   */
+  getAll(headerName: string): string[] {
+    return this.headers.get(headerName.toLowerCase()) || new Array<string>();
+  }
+}
+
 /** HTTP request. */
 export class HttpRequest {
   protocol: HttpProtocol;
   method: HttpMethod;
+  headers: HttpHeaders;
   body?: string;
 
   public constructor(builder: HttpRequestBuilder) {
     this.protocol = builder.protocol;
     this.method = builder.method;
+    this.headers = builder.headers;
     this.body = builder.body;
   }
 }
 
 export class HttpRequestBuilder {
   protocol?: HttpProtocol;
   method?: HttpMethod;
+  headers?: HttpHeaders;
   body?: string;
 
   withProtocol(protocol: HttpProtocol): this {
@@ -61,30 +111,43 @@ export class HttpRequestBuilder {
     return this;
   }
 
+  withHeaders(headers: HttpHeaders): this {
+    this.headers = headers;
+    return this;
+  }
+
   build(): HttpRequest {
     return new HttpRequest(this);
   }
 }
 
 export class HttpResponse {
   statusCode?: number;
+  headers: HttpHeaders;
   body?: string;
 
   constructor(builder: HttpResponseBuilder) {
     this.statusCode = builder.statusCode;
+    this.headers = builder.headers;
     this.body = builder.body;
   }
 }
 
 export class HttpResponseBuilder {
   statusCode?: number;
+  headers?: HttpHeaders;
   body?: string;
 
   withStatusCode(statusCode: number): this {
     this.statusCode = statusCode;
     return this;
   }
 
+  withHeaders(headers: HttpHeaders): this {
+    this.headers = headers;
+    return this;
+  }
+
   withBody(body: string): this {
     this.body = body;
     return this;
@@ -112,14 +175,23 @@ export class HttpExchangeReader {
       HttpProtocol[(parsedRequest.protocol as string).toUpperCase()];
     const method: HttpMethod =
       HttpMethod[(parsedRequest.method as string).toUpperCase()];
+    const requestHeaders: HttpHeaders = new HttpHeaders(parsedRequest.headers);
 
     const request = new HttpRequestBuilder()
       .withProtocol(protocol)
       .withMethod(method)
+      .withHeaders(requestHeaders)
+      .withBody(parsedRequest.body)
       .build();
 
+    const responseHeaders: HttpHeaders = new HttpHeaders(
+      parsedResponse.headers
+    );
+
     const response = new HttpResponseBuilder()
       .withStatusCode(parsedResponse.statusCode)
+      .withHeaders(responseHeaders)
+      .withBody(parsedResponse.body)
       .build();
 
     return new HttpExchange(request, response);

test/index.test.ts

@@ -41,15 +41,38 @@ test("Http exchanges from JSON", () => {
   const json = `{
     "request": {
       "protocol": "https",
-      "method": "post"
+      "method": "post",
+      "headers": {
+        "accept": "*/*",
+        "multi-value": ["value1", "value2"]
+      },
+      "body": "a request body"
     },
     "response": {
-      "statusCode": 404
+      "statusCode": 404,
+      "headers": {
+        "content-length": "15",
+        "Upper-Case": "yes"
+      },
+      "body": "a response body"
     }
   }`;
 
   const exchange = HttpExchangeReader.fromJson(json);
+
   expect(exchange.request.protocol).toBe(HttpProtocol.HTTPS);
   expect(exchange.request.method).toBe(HttpMethod.POST);
+  expect(exchange.request.headers.get("accept")).toBe("*/*");
+  expect(exchange.request.headers.get("multi-value")).toBe("value1");
+  expect(exchange.request.headers.getAll("multi-value")).toEqual([
+    "value1",
+    "value2"
+  ]);
+  expect(exchange.request.body).toBe("a request body");
+
   expect(exchange.response.statusCode).toBe(404);
+  expect(exchange.response.headers.get("content-length")).toBe("15");
+  expect(exchange.response.headers.get("Upper-Case")).toBe("yes");
+  expect(exchange.response.headers.get("upper-case")).toBe("yes");
+  expect(exchange.response.body).toBe("a response body");
 });