add search service

add alphabetical search POST to search service
add headers to http POST
add post tests for alphabetical search
update http POST test

Author: ethatcher83

src/client.ts

@@ -7,6 +7,7 @@ import { BasketService, OrderService, CertificateService, CertifiedCopiesService
 import { PaymentService } from "./services/payment/";
 import CompanyFilingHistoryService from "./services/company-filing-history/service";
 import { RefreshTokenService } from "./services/refresh-token";
+import AlphabeticalSearchService from "./services/search/alphabetical-search/service";
 
 /**
  * ApiClient is the class that all service objects hang off.
@@ -24,6 +25,7 @@ export default class ApiClient {
   public readonly order: OrderService;
   public readonly mid : MidService;
   public readonly refreshToken: RefreshTokenService;
+  public readonly alphabeticalSearch: AlphabeticalSearchService;
 
   constructor (readonly apiClient: IHttpClient, readonly accountClient: IHttpClient) {
       // services on the api domain using the apiClient
@@ -38,6 +40,7 @@ export default class ApiClient {
       this.payment = new PaymentService(apiClient); // TODO split payments url/domain into a separate config item and http client
       this.order = new OrderService(apiClient);
       this.mid = new MidService(apiClient);
+      this.alphabeticalSearch = new AlphabeticalSearchService(apiClient);
       // service on the account/identity domain using the accountClient
       // e.g. user profile service can be added here when required
       this.refreshToken = new RefreshTokenService(accountClient);

src/http/http-client.ts

@@ -64,7 +64,7 @@ export default interface IHttpClient {
    * @param url the url relative to the base url
    */
   httpGet(url: string): Promise<HttpResponse>;
-  httpPost(url: string, body?: any): Promise<HttpResponse>;
+  httpPost(url: string, body?: any, headers?: Headers): Promise<HttpResponse>;
   httpPatch(url: string, body?: any, headers?: Headers): Promise<HttpResponse>;
   httpPut(url: string, body?: any, headers?: Headers): Promise<HttpResponse>;
   httpDelete(url: string): Promise<HttpResponse>;
@@ -124,7 +124,7 @@ export abstract class AbstractClient implements IHttpClient {
    */
   public abstract httpGet(url: string): Promise<HttpResponse>;
 
-  public abstract httpPost(url: string, body?: any): Promise<HttpResponse>;
+  public abstract httpPost(url: string, body?: any, headers?: Headers): Promise<HttpResponse>;
 
   public abstract httpPatch(url: string, body?: any, headers?: Headers): Promise<HttpResponse>;
 

src/http/request-client.ts

@@ -10,8 +10,8 @@ export default class RequestClient extends AbstractClient {
         return this.request({ method: "GET", url });
     }
 
-    public async httpPost (url: string, body?: any): Promise<HttpResponse> {
-        return this.request({ method: "POST", url, body });
+    public async httpPost (url: string, body?: any, headers?: Headers): Promise<HttpResponse> {
+        return this.request({ method: "POST", url, body, headers });
     }
 
     public async httpPatch (url: string, body?: any, headers?: Headers): Promise<HttpResponse> {

src/services/search/alphabetical-search/index.ts

@@ -0,0 +1,2 @@
+export { default as AlphabeticalSearchService } from "./service";
+export * from "./types";

src/services/search/alphabetical-search/service.ts

@@ -0,0 +1,27 @@
+import { IHttpClient } from "../../../http";
+import { AlphabeticalSearchPostRequest, CompaniesResource } from "./types";
+import Resource from "../../resource";
+
+export default class AlphabeticalSearchService {
+    constructor (private readonly client: IHttpClient) { }
+    public async getCompanies (companyName: AlphabeticalSearchPostRequest, requestId: string): Promise<Resource<CompaniesResource>> {
+        const additionalHeaders = {
+            "X-Request-ID": requestId,
+            "Content-Type": "application/json"
+        }
+
+        const resp = await this.client.httpPost("/alphabetical-search/corporate-name", companyName, additionalHeaders);
+
+        const resource: Resource<CompaniesResource> = {
+            httpStatusCode: resp.status
+        };
+
+        if (resp.error) {
+            return resource;
+        }
+
+        resource.resource = resp.body as CompaniesResource;
+
+        return resource;
+    }
+}

src/services/search/alphabetical-search/types.ts

@@ -0,0 +1,28 @@
+export interface CompaniesResource {
+    searchType: string;
+    topHit: string;
+    results: Result[];
+}
+
+export interface Result {
+    ID: string;
+    company_type: string;
+    items: Items;
+    links: Links;
+}
+
+export interface Items {
+    company_number: string;
+    company_status: string;
+    corporate_name: string;
+    record_type: string;
+}
+
+export interface Links {
+    self: string;
+}
+
+// AlphabeticalSearchPostRequest
+export interface AlphabeticalSearchPostRequest {
+    company_name: string
+}

test/http/http-client.spec.ts

@@ -3,7 +3,7 @@ import { AbstractClient, HttpResponse } from "../../src/http";
 const expect = chai.expect;
 
 class TestClient extends AbstractClient {
-    public httpPost (url: string, body: any): Promise<HttpResponse> {
+    public httpPost (url: string, body: any, headers: any): Promise<HttpResponse> {
         throw new Error("Method not implemented.");
     }
 

test/services/search/alphabetical-search/service.spec.ts

@@ -0,0 +1,84 @@
+import chai from "chai";
+import sinon from "sinon";
+
+import { AlphabeticalSearchService } from "../../../../src/services/search/alphabetical-search";
+import { RequestClient } from "../../../../src/http";
+import { AlphabeticalSearchPostRequest, CompaniesResource } from "../../../../src/services/search/alphabetical-search/types";
+import Resource from "../../../../src/services/resource";
+const expect = chai.expect;
+
+const requestClient = new RequestClient({ baseUrl: "URL-NOT-USED", oauthToken: "TOKEN-NOT-USED" });
+
+const mockResponseBody : CompaniesResource = ({
+    searchType: "",
+    topHit: "TEST COMPANY",
+    results: [
+        {
+            ID: "FC022000",
+            company_type: "oversea-company",
+            items: {
+                company_number: "FC022000",
+                company_status: "active",
+                corporate_name: "corporate name",
+                record_type: "record type"
+            },
+            links: {
+                self: "/company/FC022000"
+            }
+        }
+    ]
+});
+
+const mockRequestBody: AlphabeticalSearchPostRequest = ({
+    company_name: "TEST"
+});
+
+const mockRequestId = "fdskfhsdoifhsffsif";
+
+describe("create a alphabetical search POST", () => {
+    beforeEach(() => {
+        sinon.reset();
+        sinon.restore();
+    });
+
+    afterEach(done => {
+        sinon.reset();
+        sinon.restore();
+        done();
+    });
+
+    it("returns an error response on failure", async () => {
+        const mockPostRequest = {
+            status: 401,
+            error: "An error occurred"
+        };
+
+        const mockRequest = sinon.stub(requestClient, "httpPost").resolves(mockPostRequest);
+        const search: AlphabeticalSearchService = new AlphabeticalSearchService(requestClient);
+        const data: Resource<CompaniesResource> = await search.getCompanies(mockRequestBody, mockRequestId);
+
+        expect(data.httpStatusCode).to.equal(401);
+        expect(data.resource).to.be.undefined;
+    });
+
+    it("returns alphabetical search results correctly", async () => {
+        const mockPostRequest = {
+            status: 200,
+            body: mockResponseBody
+        };
+
+        const mockRequest = sinon.stub(requestClient, "httpPost").resolves(mockPostRequest);
+        const search: AlphabeticalSearchService = new AlphabeticalSearchService(requestClient);
+        const data: Resource<CompaniesResource> = await search.getCompanies(mockRequestBody, mockRequestId);
+
+        expect(data.httpStatusCode).to.equal(200);
+        expect(data.resource.topHit).to.equal(mockResponseBody.topHit);
+        expect(data.resource.results[0].ID).to.equal(mockResponseBody.results[0].ID);
+        expect(data.resource.results[0].company_type).to.equal(mockResponseBody.results[0].company_type)
+        expect(data.resource.results[0].items.company_number).to.equal(mockResponseBody.results[0].items.company_number);
+        expect(data.resource.results[0].items.company_status).to.equal(mockResponseBody.results[0].items.company_status);
+        expect(data.resource.results[0].items.corporate_name).to.equal(mockResponseBody.results[0].items.corporate_name);
+        expect(data.resource.results[0].items.record_type).to.equal(mockResponseBody.results[0].items.record_type);
+        expect(data.resource.results[0].links).to.equal(mockResponseBody.results[0].links);
+    });
+});