Build has been canceled!

3241833607

Build Type

github

Committed by GitHub

Commit Message

Merge c1e7ccfac into 0ed9dcad2

Pull Request Pull Request #973: Improve test coverage

Run Details

1532 of 3546 branches covered (43.2%)

Branch coverage included in aggregate %.

273 of 284 new or added lines in 13 files covered. (96.13%)

1 existing line in 1 file now uncovered.

6554 of 10330 relevant lines covered (63.45%)

48.98 hits per line

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

96.88

/src/test-utils/HTTPClient.ts

import { Agent } from "http";
import { HeaderObject, HTTPParser } from "http-parser-js";
import { Socket } from "net";
import { HAPEncryption } from "../lib/util/eventedhttp";
import * as hapCrypto from "../lib/util/hapCrypto";

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

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

  private currentSocket?: Socket;

  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;
  }

  popReceiveBuffer(encryption?: HAPEncryption): Buffer {
    expect(this.currentSocket).not.toBeUndefined();
    expect(this.dataQueue.length > 0).toBeTruthy();
    const buffer = this.dataQueue.splice(0, 1)[0];
    if (encryption) {
      return hapCrypto.layerDecrypt(buffer, 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;
  }

  writeHTTPRequest(method: "GET" | "POST" | "PUT" | "DELETE", route: string, data?: Buffer): void {
    this.write(this.formatHTTPRequest(method, route, data));
  }

  write(data: Buffer, encryption?: HAPEncryption): void {
    if (encryption) {
      data = hapCrypto.layerEncrypt(data, encryption);
    }
    expect(this.currentSocket).not.toBeUndefined();
    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;
  }

  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 { Agent } from "http";
2	import { HeaderObject, HTTPParser } from "http-parser-js";	6✔
3	import { Socket } from "net";
4	import { HAPEncryption } from "../lib/util/eventedhttp";
5	import * as hapCrypto from "../lib/util/hapCrypto";	6✔
6
7	export interface HTTPResponse {
8	shouldKeepAlive: boolean;
9	upgrade: boolean;
10	statusCode: number;
11	statusMessage: string;
12	versionMajor: number;
13	versionMinor: number;
14	headers: Record<string, string>;
15	body: Buffer;
16	trailers: string[];
17	}
18
19	/**
20	* A http client that wraps around a http agent.
21	*/
22	export class HTTPClient {	6✔
23	private readonly agent: Agent;
24	private readonly address: string;
25	private readonly port: number;
26
27	private currentSocket?: Socket;
28
29	private currentDataListener?: (data: Buffer) => void;
30	private dataQueue: Buffer[] = [];	21✔
31
32	constructor(agent: Agent, address: string, port: number) {
33	this.agent = agent;	21✔
34	this.address = address;	21✔
35	this.port = port;	21✔
36	}
37
38	attachSocket(): void {	21✔
39	expect(this.currentSocket).toBeUndefined();	21✔
40	expect(this.currentDataListener).toBeUndefined();	21✔
41
42	// we extract the underlying TCP socket!
43	// eslint-disable-next-line @typescript-eslint/no-explicit-any
44	const freeSockets = ((this.agent as any).freeSockets as Record<string, [Socket]>);	21✔
45	expect(Object.values(freeSockets).length).toBe(1);	21✔
46	this.currentSocket = Object.values(freeSockets)[0][0];	21✔
47
48	this.currentDataListener = data => {	21✔
49	// packets shall fit into a single TCP segment, no need to write a parser!
50	this.dataQueue.push(data);	36✔
51	};
52	this.currentSocket.on("data", this.currentDataListener);	21✔
53	}
54
55	get receiveBufferCount(): number {	6✔
56	return this.dataQueue.length;	48✔
57	}
58
59	popReceiveBuffer(encryption?: HAPEncryption): Buffer {	6✔
60	expect(this.currentSocket).not.toBeUndefined();	36✔
61	expect(this.dataQueue.length > 0).toBeTruthy();	36✔
62	const buffer = this.dataQueue.splice(0, 1)[0];	36✔
63	if (encryption) {	36✔
64	return hapCrypto.layerDecrypt(buffer, encryption);	18✔
65	}
66	return buffer;	18✔
67	}
68
69	formatHTTPRequest(	6✔
70	method: "GET" \| "POST" \| "PUT" \| "DELETE",
71	route: string,
72	data?: Buffer,
73	contentType = "application/json",	45✔
74	): Buffer {
75	expect(!!data \|\| method === "GET").toBeTruthy();	27✔
76	const buffer = Buffer.from(`${method} ${route} HTTP/1.1\r\n` +	27✔
77	"Accept: application/json, text/plain, /\r\n" +
78	"User-Agent: test-util\r\n" +
79	"Host: " + this.address + ":" + this.port + "\r\n" +
80	"Connection: keep-alive\r\n" +
81	(data	27✔
82	? "Content-Type: " + contentType + "\r\n" +
83	"Content-Length: " + data.length + "\r\n"
84	: ""
85	) +
86	"\r\n");
87
88	if (data) {	27✔
89	return Buffer.concat([buffer, data]);	9✔
90	}
91
92	return buffer;	18✔
93	}
94
95	writeHTTPRequest(method: "GET" \| "POST" \| "PUT" \| "DELETE", route: string, data?: Buffer): void {	6✔
96	this.write(this.formatHTTPRequest(method, route, data));	9✔
97	}
98
99	write(data: Buffer, encryption?: HAPEncryption): void {	6✔
100	if (encryption) {	27✔
101	data = hapCrypto.layerEncrypt(data, encryption);	18✔
102	}
103	expect(this.currentSocket).not.toBeUndefined();	27✔
104	this.currentSocket!.write(data);	27✔
105	}
106
107	releaseSocket(): void {	6✔
108	if (this.currentSocket && this.currentDataListener) {	3✔
109	this.currentSocket.removeListener("data", this.currentDataListener);	3✔
110	this.currentDataListener = undefined;	3✔
111	}
112
113	expect(this.currentDataListener).toBeUndefined();	3✔
114
115	this.currentSocket = undefined;	3✔
116	}
117
118	parseHTTPResponse(input: Buffer): HTTPResponse {	6✔
119	// taken and adapted from https://github.com/creationix/http-parser-js/blob/88c665381470e27cd428a728447a13dce198f782/standalone-example.js#L73
120	const parser = new HTTPParser(HTTPParser.RESPONSE);	18✔
121
122	let complete = false;	18✔
123	let shouldKeepAlive = false;	18✔
124	let upgrade = false;	18✔
125	let statusCode = 0;	18✔
126	let statusMessage = "";	18✔
127	let versionMajor = 0;	18✔
128	let versionMinor = 0;	18✔
129	let headers: HeaderObject = [];	18✔
130	let trailers: string[] = [];	18✔
131	const bodyChunks: Buffer[] = [];	18✔
132
133	parser[HTTPParser.kOnHeadersComplete] = info => {	18✔
134	shouldKeepAlive = info.shouldKeepAlive;	18✔
135	upgrade = info.upgrade;	18✔
136	statusCode = info.statusCode;	18✔
137	statusMessage = info.statusMessage;	18✔
138	versionMajor = info.versionMajor;	18✔
139	versionMinor = info.versionMinor;	18✔
140	headers = info.headers;	18✔
141	};
142
143	parser[HTTPParser.kOnBody] = (chunk, offset, length) => {	18✔
144	bodyChunks.push(chunk.slice(offset, offset + length));	18✔
145	};
146
147	// that's the event for trailers!
148	parser[HTTPParser.kOnHeaders] = t => {	18✔
NEW 149	trailers = t;	×
150	};
151
152	parser[HTTPParser.kOnMessageComplete] = () => {	18✔
153	complete = true;	18✔
154	};
155
156	// Since we are sending the entire Buffer at once here all callbacks above happen synchronously.
157	// The parser does not do _anything_ asynchronous.
158	// However, you can of course call execute() multiple times with multiple chunks, e.g. from a stream.
159	// But then you have to refactor the entire logic to be async (e.g. resolve a Promise in kOnMessageComplete and add timeout logic).
160	parser.execute(input);	18✔
161	parser.finish();	18✔
162
163	if (!complete) {	18!
NEW 164	throw new Error("Failed to parse input: " + input.toString());	×
165	}
166
167	const body = Buffer.concat(bodyChunks);	18✔
168
169	return {	18✔
170	shouldKeepAlive,
171	upgrade,
172	statusCode,
173	statusMessage,
174	versionMajor,
175	versionMinor,
176	headers: this.headersArrayToObject(headers),
177	body,
178	trailers,
179	};
180	}
181
182	private headersArrayToObject(headers: HeaderObject): Record<string, string> {	6✔
183	expect(headers.length % 2).toBe(0);	18✔
184
185	const result: Record<string, string> = {};	18✔
186
187	for (let i = 0; i < headers.length; i += 2) {	18✔
188	result[headers[i]] = headers[i+1];	72✔
189	}
190
191	return result;	18✔
192	}
193	}	6✔

homebridge / HAP-NodeJS / 3241833607

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