3409394823

Build Type

github

Committed by GitHub

Commit Message

Merge 64e7e3a10 into deeb8d1eb

Pull Request Pull Request #973: Improve test coverage

Run Details

1637 of 3632 branches covered (45.07%)

Branch coverage included in aggregate %.

398 of 445 new or added lines in 17 files covered. (89.44%)

1 existing line in 1 file now uncovered.

6895 of 10577 relevant lines covered (65.19%)

209.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.29

/src/test-utils/HAPHTTPClient.ts

import assert from "assert";
import { Agent } from "http";
import { HeaderObject, HTTPParser } from "http-parser-js";
import { Socket } from "net";
import {
  AccessoriesResponse,
  CharacteristicId,
  CharacteristicsReadResponse,
  CharacteristicsWriteRequest,
  CharacteristicsWriteResponse, HAPMimeTypes, PairingStates, PairMethods,
  PrepareWriteRequest,
  ResourceRequest, TLVValues,
} from "../internal-types";
import { HAPHTTPCode, HAPPairingHTTPCode } from "../lib/HAPServer";
import { PairingInformation, PermissionTypes } from "../lib/model/AccessoryInfo";
import { HAPEncryption, HAPUsername } from "../lib/util/eventedhttp";
import * as hapCrypto from "../lib/util/hapCrypto";
import { HAPHTTPError } from "../lib/util/HAPHTTPError";
import { PromiseTimeout } from "../lib/util/promise-utils";
import * as tlv from "../lib/util/tlv";
import { TLVError } from "../lib/util/tlvError";

export interface HTTPResponse<T = Buffer> {
  shouldKeepAlive: boolean;
  upgrade: boolean;
  statusCode: number;
  statusMessage: string;
  versionMajor: number;
  versionMinor: number;
  headers: Record<string, string>;
  body: T;
  trailers: string[];
}

/**
 * A http client that wraps around a http agent.
 */
export class HAPHTTPClient {
  private readonly agent: Agent;
  private readonly address: string;
  private readonly port: number;

  private currentSocket?: Socket;
  private encryption?: HAPEncryption;

  private currentDataListener?: (data: Buffer) => void;
  private dataQueue: Buffer[] = [];

  constructor(agent: Agent, address: string, port: number) {
    this.agent = agent;
    this.address = address;
    this.port = port;
  }

  attachSocket(): void {
    expect(this.currentSocket).toBeUndefined();
    expect(this.currentDataListener).toBeUndefined();

    // we extract the underlying TCP socket!
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    const freeSockets = ((this.agent as any).freeSockets as Record<string, [Socket]>);
    expect(Object.values(freeSockets).length).toBe(1);
    this.currentSocket = Object.values(freeSockets)[0][0];

    this.currentDataListener = data => {
      // packets shall fit into a single TCP segment, no need to write a parser!
      this.dataQueue.push(data);
    };
    this.currentSocket.on("data", this.currentDataListener);
  }

  get receiveBufferCount(): number {
    return this.dataQueue.length;
  }

  enableEncryption(encryption: HAPEncryption): void {
    this.encryption = encryption;
  }

  disableEncryption(): void {
    this.encryption = undefined;
  }

  popReceiveBuffer(): Buffer {
    expect(this.currentSocket).toBeDefined();
    expect(this.dataQueue.length > 0).toBeTruthy();
    const buffer = this.dataQueue.splice(0, 1)[0];
    if (this.encryption) {
      return hapCrypto.layerDecrypt(buffer, this.encryption);
    }
    return buffer;
  }

  formatHTTPRequest(
    method: "GET" | "POST" | "PUT" | "DELETE",
    route: string,
    data?: Buffer,
    contentType = "application/json",
  ): Buffer {
    expect(!!data || method === "GET").toBeTruthy();
    const buffer = Buffer.from(`${method} ${route} HTTP/1.1\r\n` +
      "Accept: application/json, text/plain, */*\r\n" +
      "User-Agent: test-util\r\n" +
      "Host: " + this.address + ":" + this.port + "\r\n" +
      "Connection: keep-alive\r\n" +
      (data
        ? "Content-Type: " + contentType + "\r\n" +
          "Content-Length: " + data.length + "\r\n"
        : ""
      ) +
      "\r\n");

    if (data) {
      return Buffer.concat([buffer, data]);
    }

    return buffer;
  }

  async writeHTTPRequest(method: "GET" | "POST" | "PUT" | "DELETE", route: string, data?: Buffer, contentType?: string): Promise<HTTPResponse> {
    const httpRequest = this.formatHTTPRequest(method, route, data, contentType);
    this.write(httpRequest);

    await PromiseTimeout(20);

    const responseBuffer = this.popReceiveBuffer();
    return this.parseHTTPResponse(responseBuffer);
  }

  write(data: Buffer): void {
    if (this.encryption) {
      data = hapCrypto.layerEncrypt(data, this.encryption);
    }
    expect(this.currentSocket).toBeDefined();
    this.currentSocket!.write(data);
  }

  releaseSocket(): void {
    if (this.currentSocket && this.currentDataListener) {
      this.currentSocket.removeListener("data", this.currentDataListener);
      this.currentDataListener = undefined;
    }

    expect(this.currentDataListener).toBeUndefined();

    this.currentSocket = undefined;
  }

  async sendAddPairingRequest(identifier: HAPUsername, publicKey: Buffer, permission: PermissionTypes): Promise<void> {
    const requestTLV = tlv.encode(
      TLVValues.METHOD, PairMethods.ADD_PAIRING,
      TLVValues.STATE, PairingStates.M1,
      TLVValues.IDENTIFIER, identifier,
      TLVValues.PUBLIC_KEY, publicKey,
      TLVValues.PERMISSIONS, permission,
    );

    await this.sendPairingsRequest(requestTLV);
  }

  async sendRemovePairingRequest(identifier: HAPUsername): Promise<void> {
    const requestTLV = tlv.encode(
      TLVValues.METHOD, PairMethods.REMOVE_PAIRING,
      TLVValues.STATE, PairingStates.M1,
      TLVValues.IDENTIFIER, identifier,
    );

    await this.sendPairingsRequest(requestTLV);
  }

  async sendListPairingsRequest(): Promise<PairingInformation[]> {
    const requestTLV = tlv.encode(
      TLVValues.METHOD, PairMethods.LIST_PAIRINGS,
      TLVValues.STATE, PairingStates.M1,
    );

    const responseBody = await this.sendPairingsRequest(requestTLV);
    const tlvDataList = tlv.decodeList(responseBody.slice(3), TLVValues.IDENTIFIER);

    const result: PairingInformation[] = [];

    for (const element of tlvDataList) {
      result.push({
        username: element[TLVValues.IDENTIFIER].toString(),
        publicKey: element[TLVValues.PUBLIC_KEY],
        permission: element[TLVValues.PERMISSIONS].readUInt8(0),
      });
    }

    return result;
  }

  private async sendPairingsRequest(requestTLV: Buffer): Promise<Buffer> {
    const httpResponse = await this.writeHTTPRequest("POST", "/pairings", requestTLV, HAPMimeTypes.PAIRING_TLV8);

    // `/pairings` errors are transported via the tlv8 record
    expect(httpResponse.statusCode).toEqual(HAPPairingHTTPCode.OK);
    expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.PAIRING_TLV8);

    const tlvData = tlv.decode(httpResponse.body);
    expect(tlvData[TLVValues.STATE].readUInt8(0)).toEqual(PairingStates.M2);

    if (tlvData[TLVValues.ERROR_CODE]) {
      throw new TLVError(tlvData[TLVValues.ERROR_CODE].readUInt8(0));
    }

    // we return the raw buffer because LIST_PAIRINGS has some custom decoding strategies!
    return httpResponse.body;
  }

  public async sendAccessoriesRequest(): Promise<AccessoriesResponse> {
    const httpResponse = await this.writeHTTPRequest("GET", "/accessories");
    expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);
    const jsonBody = JSON.parse(httpResponse.body.toString());

    if (httpResponse.statusCode !== HAPPairingHTTPCode.OK) {
      throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);
    }

    return jsonBody;
  }

  public async sendCharacteristicRead(
    ids: CharacteristicId[],
    includeMeta?: boolean,
    includePerms?: boolean,
    includeType?: boolean,
    includeEvent?: boolean,
  ): Promise<HTTPResponse<CharacteristicsReadResponse>> {
    assert(ids.length > 0);
    let query = "?id=" + ids.map(id => id.aid + "." + id.iid).join(",");

    if (includeMeta) {
      query += "&meta=" + (includeMeta ? "true" : "false");
    }
    if (includePerms) {
      query += "&perms=" + (includePerms ? "1" : "0");
    }
    if (includeType) {
      query += "&type=" + (includeType ? "true" : "false");
    }
    if (includeEvent) {
      query += "&ev=" + (includeEvent ? "1" : "0");
    }

    const httpResponse = await this.writeHTTPRequest("GET", "/characteristics" + query);
    expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);

    const body = JSON.parse(httpResponse.body.toString());
    if (!httpResponse.statusCode.toString().startsWith("2")) {
      throw new HAPHTTPError(httpResponse.statusCode, body.status);
    }

    return {
      ...httpResponse,
      body: body,
    };
  }

  public async sendCharacteristicWrite(writeRequest: CharacteristicsWriteRequest): Promise<HTTPResponse<CharacteristicsWriteResponse | undefined>> {
    const httpResponse = await this.writeHTTPRequest("PUT", "/characteristics", Buffer.from(JSON.stringify(writeRequest)), HAPMimeTypes.HAP_JSON);
    if (httpResponse.statusCode !== HAPHTTPCode.NO_CONTENT) {
      expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);
    }

    if (!httpResponse.statusCode.toString().startsWith("2")) {
      const jsonBody = JSON.parse(httpResponse.body.toString());
      throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);
    }

    return {
      ...httpResponse,
      body: httpResponse.body.length > 0 ? JSON.parse(httpResponse.body.toString()) : undefined,
    };
  }

  public async sendPrepareWrite(prepareWrite: PrepareWriteRequest): Promise<void> {
    const httpResponse = await this.writeHTTPRequest("PUT", "/prepare", Buffer.from(JSON.stringify(prepareWrite)), HAPMimeTypes.HAP_JSON);
    expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);

    if (httpResponse.statusCode !== HAPHTTPCode.OK) {
      const jsonBody = JSON.parse(httpResponse.body.toString());
      throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);
    }
  }

  public async sendResourceRequest(resourceRequest: ResourceRequest): Promise<Buffer> {
    const httpResponse = await this.writeHTTPRequest("POST", "/resource", Buffer.from(JSON.stringify(resourceRequest)), HAPMimeTypes.HAP_JSON);

    if (httpResponse.statusCode !== HAPHTTPCode.OK) {
      expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);
      const jsonBody = JSON.parse(httpResponse.body.toString());
      throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);
    }

    expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.IMAGE_JPEG);
    return httpResponse.body;
  }

  parseHTTPResponse(input: Buffer): HTTPResponse {
    // taken and adapted from https://github.com/creationix/http-parser-js/blob/88c665381470e27cd428a728447a13dce198f782/standalone-example.js#L73
    const parser = new HTTPParser(HTTPParser.RESPONSE);

    let complete = false;
    let shouldKeepAlive = false;
    let upgrade = false;
    let statusCode = 0;
    let statusMessage = "";
    let versionMajor = 0;
    let versionMinor = 0;
    let headers: HeaderObject = [];
    let trailers: string[] = [];
    const bodyChunks: Buffer[] = [];

    parser[HTTPParser.kOnHeadersComplete] = info => {
      shouldKeepAlive = info.shouldKeepAlive;
      upgrade = info.upgrade;
      statusCode = info.statusCode;
      statusMessage = info.statusMessage;
      versionMajor = info.versionMajor;
      versionMinor = info.versionMinor;
      headers = info.headers;
    };

    parser[HTTPParser.kOnBody] = (chunk, offset, length) => {
      bodyChunks.push(chunk.slice(offset, offset + length));
    };

    // that's the event for trailers!
    parser[HTTPParser.kOnHeaders] = t => {
      trailers = t;
    };

    parser[HTTPParser.kOnMessageComplete] = () => {
      complete = true;
    };

    // Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
    // The parser does not do _anything_ asynchronous.
    // However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
    // But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
    parser.execute(input);
    parser.finish();

    if (!complete) {
      throw new Error("Failed to parse input: " + input.toString());
    }

    const body = Buffer.concat(bodyChunks);

    return {
      shouldKeepAlive,
      upgrade,
      statusCode,
      statusMessage,
      versionMajor,
      versionMinor,
      headers: this.headersArrayToObject(headers),
      body,
      trailers,
    };
  }

  private headersArrayToObject(headers: HeaderObject): Record<string, string> {
    expect(headers.length % 2).toBe(0);

    const result: Record<string, string> = {};

    for (let i = 0; i < headers.length; i += 2) {
      result[headers[i]] = headers[i+1];
    }

    return result;
  }
}

1	import assert from "assert";	6✔
2	import { Agent } from "http";
3	import { HeaderObject, HTTPParser } from "http-parser-js";	6✔
4	import { Socket } from "net";
5	import {
6	AccessoriesResponse,
7	CharacteristicId,
8	CharacteristicsReadResponse,
9	CharacteristicsWriteRequest,
10	CharacteristicsWriteResponse, HAPMimeTypes, PairingStates, PairMethods,
11	PrepareWriteRequest,
12	ResourceRequest, TLVValues,
13	} from "../internal-types";
14	import { HAPHTTPCode, HAPPairingHTTPCode } from "../lib/HAPServer";
15	import { PairingInformation, PermissionTypes } from "../lib/model/AccessoryInfo";
16	import { HAPEncryption, HAPUsername } from "../lib/util/eventedhttp";
17	import * as hapCrypto from "../lib/util/hapCrypto";	6✔
18	import { HAPHTTPError } from "../lib/util/HAPHTTPError";	6✔
19	import { PromiseTimeout } from "../lib/util/promise-utils";	6✔
20	import * as tlv from "../lib/util/tlv";	6✔
21	import { TLVError } from "../lib/util/tlvError";	6✔
22
23	export interface HTTPResponse<T = Buffer> {
24	shouldKeepAlive: boolean;
25	upgrade: boolean;
26	statusCode: number;
27	statusMessage: string;
28	versionMajor: number;
29	versionMinor: number;
30	headers: Record<string, string>;
31	body: T;
32	trailers: string[];
33	}
34
35	/**
36	* A http client that wraps around a http agent.
37	*/
38	export class HAPHTTPClient {	6✔
39	private readonly agent: Agent;
40	private readonly address: string;
41	private readonly port: number;
42
43	private currentSocket?: Socket;
44	private encryption?: HAPEncryption;
45
46	private currentDataListener?: (data: Buffer) => void;
47	private dataQueue: Buffer[] = [];	36✔
48
49	constructor(agent: Agent, address: string, port: number) {
50	this.agent = agent;	36✔
51	this.address = address;	36✔
52	this.port = port;	36✔
53	}
54
55	attachSocket(): void {	36✔
56	expect(this.currentSocket).toBeUndefined();	36✔
57	expect(this.currentDataListener).toBeUndefined();	36✔
58
59	// we extract the underlying TCP socket!
60	// eslint-disable-next-line @typescript-eslint/no-explicit-any
61	const freeSockets = ((this.agent as any).freeSockets as Record<string, [Socket]>);	36✔
62	expect(Object.values(freeSockets).length).toBe(1);	36✔
63	this.currentSocket = Object.values(freeSockets)[0][0];	36✔
64
65	this.currentDataListener = data => {	36✔
66	// packets shall fit into a single TCP segment, no need to write a parser!
67	this.dataQueue.push(data);	57✔
68	};
69	this.currentSocket.on("data", this.currentDataListener);	36✔
70	}
71
72	get receiveBufferCount(): number {	6✔
73	return this.dataQueue.length;	36✔
74	}
75
76	enableEncryption(encryption: HAPEncryption): void {	6✔
77	this.encryption = encryption;	33✔
78	}
79
80	disableEncryption(): void {	6✔
NEW 81	this.encryption = undefined;	×
82	}
83
84	popReceiveBuffer(): Buffer {	6✔
85	expect(this.currentSocket).toBeDefined();	57✔
86	expect(this.dataQueue.length > 0).toBeTruthy();	57✔
87	const buffer = this.dataQueue.splice(0, 1)[0];	57✔
88	if (this.encryption) {	57✔
89	return hapCrypto.layerDecrypt(buffer, this.encryption);	39✔
90	}
91	return buffer;	18✔
92	}
93
94	formatHTTPRequest(	6✔
95	method: "GET" \| "POST" \| "PUT" \| "DELETE",
96	route: string,
97	data?: Buffer,
98	contentType = "application/json",	69✔
99	): Buffer {
100	expect(!!data \|\| method === "GET").toBeTruthy();	48✔
101	const buffer = Buffer.from(`${method} ${route} HTTP/1.1\r\n` +	48✔
102	"Accept: application/json, text/plain, /\r\n" +
103	"User-Agent: test-util\r\n" +
104	"Host: " + this.address + ":" + this.port + "\r\n" +
105	"Connection: keep-alive\r\n" +
106	(data	48✔
107	? "Content-Type: " + contentType + "\r\n" +
108	"Content-Length: " + data.length + "\r\n"
109	: ""
110	) +
111	"\r\n");
112
113	if (data) {	48✔
114	return Buffer.concat([buffer, data]);	27✔
115	}
116
117	return buffer;	21✔
118	}
119
120	async writeHTTPRequest(method: "GET" \| "POST" \| "PUT" \| "DELETE", route: string, data?: Buffer, contentType?: string): Promise<HTTPResponse> {	6✔
121	const httpRequest = this.formatHTTPRequest(method, route, data, contentType);	39✔
122	this.write(httpRequest);	39✔
123
124	await PromiseTimeout(20);	78✔
125
126	const responseBuffer = this.popReceiveBuffer();	39✔
127	return this.parseHTTPResponse(responseBuffer);	39✔
128	}
129
130	write(data: Buffer): void {	6✔
131	if (this.encryption) {	48✔
132	data = hapCrypto.layerEncrypt(data, this.encryption);	39✔
133	}
134	expect(this.currentSocket).toBeDefined();	48✔
135	this.currentSocket!.write(data);	48✔
136	}
137
138	releaseSocket(): void {	6✔
139	if (this.currentSocket && this.currentDataListener) {	36✔
140	this.currentSocket.removeListener("data", this.currentDataListener);	36✔
141	this.currentDataListener = undefined;	36✔
142	}
143
144	expect(this.currentDataListener).toBeUndefined();	36✔
145
146	this.currentSocket = undefined;	36✔
147	}
148
149	async sendAddPairingRequest(identifier: HAPUsername, publicKey: Buffer, permission: PermissionTypes): Promise<void> {	6✔
150	const requestTLV = tlv.encode(	3✔
151	TLVValues.METHOD, PairMethods.ADD_PAIRING,
152	TLVValues.STATE, PairingStates.M1,
153	TLVValues.IDENTIFIER, identifier,
154	TLVValues.PUBLIC_KEY, publicKey,
155	TLVValues.PERMISSIONS, permission,
156	);
157
158	await this.sendPairingsRequest(requestTLV);	6✔
159	}
160
161	async sendRemovePairingRequest(identifier: HAPUsername): Promise<void> {	6✔
162	const requestTLV = tlv.encode(	3✔
163	TLVValues.METHOD, PairMethods.REMOVE_PAIRING,
164	TLVValues.STATE, PairingStates.M1,
165	TLVValues.IDENTIFIER, identifier,
166	);
167
168	await this.sendPairingsRequest(requestTLV);	6✔
169	}
170
171	async sendListPairingsRequest(): Promise<PairingInformation[]> {	6✔
172	const requestTLV = tlv.encode(	3✔
173	TLVValues.METHOD, PairMethods.LIST_PAIRINGS,
174	TLVValues.STATE, PairingStates.M1,
175	);
176
177	const responseBody = await this.sendPairingsRequest(requestTLV);	3✔
178	const tlvDataList = tlv.decodeList(responseBody.slice(3), TLVValues.IDENTIFIER);	3✔
179
180	const result: PairingInformation[] = [];	3✔
181
182	for (const element of tlvDataList) {	6✔
183	result.push({	6✔
184	username: element[TLVValues.IDENTIFIER].toString(),
185	publicKey: element[TLVValues.PUBLIC_KEY],
186	permission: element[TLVValues.PERMISSIONS].readUInt8(0),
187	});
188	}
189
190	return result;	3✔
191	}
192
193	private async sendPairingsRequest(requestTLV: Buffer): Promise<Buffer> {	6✔
194	const httpResponse = await this.writeHTTPRequest("POST", "/pairings", requestTLV, HAPMimeTypes.PAIRING_TLV8);	9✔
195
196	// `/pairings` errors are transported via the tlv8 record
197	expect(httpResponse.statusCode).toEqual(HAPPairingHTTPCode.OK);	9✔
198	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.PAIRING_TLV8);	9✔
199
200	const tlvData = tlv.decode(httpResponse.body);	9✔
201	expect(tlvData[TLVValues.STATE].readUInt8(0)).toEqual(PairingStates.M2);	9✔
202
203	if (tlvData[TLVValues.ERROR_CODE]) {	9!
NEW 204	throw new TLVError(tlvData[TLVValues.ERROR_CODE].readUInt8(0));	×
205	}
206
207	// we return the raw buffer because LIST_PAIRINGS has some custom decoding strategies!
208	return httpResponse.body;	9✔
209	}
210
211	public async sendAccessoriesRequest(): Promise<AccessoriesResponse> {	6✔
212	const httpResponse = await this.writeHTTPRequest("GET", "/accessories");	6✔
213	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);	6✔
214	const jsonBody = JSON.parse(httpResponse.body.toString());	6✔
215
216	if (httpResponse.statusCode !== HAPPairingHTTPCode.OK) {	6!
NEW 217	throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);	×
218	}
219
220	return jsonBody;	6✔
221	}
222
223	public async sendCharacteristicRead(	6✔
224	ids: CharacteristicId[],
225	includeMeta?: boolean,
226	includePerms?: boolean,
227	includeType?: boolean,
228	includeEvent?: boolean,
229	): Promise<HTTPResponse<CharacteristicsReadResponse>> {
230	assert(ids.length > 0);	6✔
231	let query = "?id=" + ids.map(id => id.aid + "." + id.iid).join(",");	12✔
232
233	if (includeMeta) {	6!
NEW 234	query += "&meta=" + (includeMeta ? "true" : "false");	×
235	}
236	if (includePerms) {	6!
NEW 237	query += "&perms=" + (includePerms ? "1" : "0");	×
238	}
239	if (includeType) {	6✔
240	query += "&type=" + (includeType ? "true" : "false");	3!
241	}
242	if (includeEvent) {	6✔
243	query += "&ev=" + (includeEvent ? "1" : "0");	3!
244	}
245
246	const httpResponse = await this.writeHTTPRequest("GET", "/characteristics" + query);	6✔
247	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);	6✔
248
249	const body = JSON.parse(httpResponse.body.toString());	6✔
250	if (!httpResponse.statusCode.toString().startsWith("2")) {	6!
NEW 251	throw new HAPHTTPError(httpResponse.statusCode, body.status);	×
252	}
253
254	return {	6✔
255	...httpResponse,
256	body: body,
257	};
258	}
259
260	public async sendCharacteristicWrite(writeRequest: CharacteristicsWriteRequest): Promise<HTTPResponse<CharacteristicsWriteResponse \| undefined>> {	6✔
261	const httpResponse = await this.writeHTTPRequest("PUT", "/characteristics", Buffer.from(JSON.stringify(writeRequest)), HAPMimeTypes.HAP_JSON);	9✔
262	if (httpResponse.statusCode !== HAPHTTPCode.NO_CONTENT) {	9✔
263	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);	6✔
264	}
265
266	if (!httpResponse.statusCode.toString().startsWith("2")) {	9!
NEW 267	const jsonBody = JSON.parse(httpResponse.body.toString());	×
NEW 268	throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);	×
269	}
270
271	return {	9✔
272	...httpResponse,
273	body: httpResponse.body.length > 0 ? JSON.parse(httpResponse.body.toString()) : undefined,	9✔
274	};
275	}
276
277	public async sendPrepareWrite(prepareWrite: PrepareWriteRequest): Promise<void> {	6✔
278	const httpResponse = await this.writeHTTPRequest("PUT", "/prepare", Buffer.from(JSON.stringify(prepareWrite)), HAPMimeTypes.HAP_JSON);	6✔
279	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);	6✔
280
281	if (httpResponse.statusCode !== HAPHTTPCode.OK) {	6!
NEW 282	const jsonBody = JSON.parse(httpResponse.body.toString());	×
NEW 283	throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);	×
284	}
285	}
286
287	public async sendResourceRequest(resourceRequest: ResourceRequest): Promise<Buffer> {	6✔
288	const httpResponse = await this.writeHTTPRequest("POST", "/resource", Buffer.from(JSON.stringify(resourceRequest)), HAPMimeTypes.HAP_JSON);	3✔
289
290	if (httpResponse.statusCode !== HAPHTTPCode.OK) {	3!
NEW 291	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.HAP_JSON);	×
NEW 292	const jsonBody = JSON.parse(httpResponse.body.toString());	×
NEW 293	throw new HAPHTTPError(httpResponse.statusCode, jsonBody.status);	×
294	}
295
296	expect(httpResponse.headers["Content-Type"]).toEqual(HAPMimeTypes.IMAGE_JPEG);	3✔
297	return httpResponse.body;	3✔
298	}
299
300	parseHTTPResponse(input: Buffer): HTTPResponse {	6✔
301	// taken and adapted from https://github.com/creationix/http-parser-js/blob/88c665381470e27cd428a728447a13dce198f782/standalone-example.js#L73
302	const parser = new HTTPParser(HTTPParser.RESPONSE);	39✔
303
304	let complete = false;	39✔
305	let shouldKeepAlive = false;	39✔
306	let upgrade = false;	39✔
307	let statusCode = 0;	39✔
308	let statusMessage = "";	39✔
309	let versionMajor = 0;	39✔
310	let versionMinor = 0;	39✔
311	let headers: HeaderObject = [];	39✔
312	let trailers: string[] = [];	39✔
313	const bodyChunks: Buffer[] = [];	39✔
314
315	parser[HTTPParser.kOnHeadersComplete] = info => {	39✔
316	shouldKeepAlive = info.shouldKeepAlive;	39✔
317	upgrade = info.upgrade;	39✔
318	statusCode = info.statusCode;	39✔
319	statusMessage = info.statusMessage;	39✔
320	versionMajor = info.versionMajor;	39✔
321	versionMinor = info.versionMinor;	39✔
322	headers = info.headers;	39✔
323	};
324
325	parser[HTTPParser.kOnBody] = (chunk, offset, length) => {	39✔
326	bodyChunks.push(chunk.slice(offset, offset + length));	36✔
327	};
328
329	// that's the event for trailers!
330	parser[HTTPParser.kOnHeaders] = t => {	39✔
NEW 331	trailers = t;	×
332	};
333
334	parser[HTTPParser.kOnMessageComplete] = () => {	39✔
335	complete = true;	39✔
336	};
337
338	// Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
339	// The parser does not do _anything_ asynchronous.
340	// However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
341	// But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
342	parser.execute(input);	39✔
343	parser.finish();	39✔
344
345	if (!complete) {	39!
NEW 346	throw new Error("Failed to parse input: " + input.toString());	×
347	}
348
349	const body = Buffer.concat(bodyChunks);	39✔
350
351	return {	39✔
352	shouldKeepAlive,
353	upgrade,
354	statusCode,
355	statusMessage,
356	versionMajor,
357	versionMinor,
358	headers: this.headersArrayToObject(headers),
359	body,
360	trailers,
361	};
362	}
363
364	private headersArrayToObject(headers: HeaderObject): Record<string, string> {	6✔
365	expect(headers.length % 2).toBe(0);	39✔
366
367	const result: Record<string, string> = {};	39✔
368
369	for (let i = 0; i < headers.length; i += 2) {	39✔
370	result[headers[i]] = headers[i+1];	150✔
371	}
372
373	return result;	39✔
374	}
375	}	6✔

homebridge / HAP-NodeJS / 3409394823

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous