1196

pending completion

Build # 1196

Build Type

Pull #275

travis-ci-com

Committed by

web-flow

Commit Message

added tests

Pull Request Pull Request #275: Add Proxy and User Agent modifier

Run Details

20 of 30 branches covered (66.67%)

Branch coverage included in aggregate %.

43 of 58 new or added lines in 3 files covered. (74.14%)

7 existing lines in 1 file now uncovered.

47 of 62 relevant lines covered (75.81%)

52.77 hits per line

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

67.95

/src/trapeze-api-client.ts

/*!
 * Source https://github.com/donmahallem/TrapezeApiClientNode
 */

import {
    ISettings,
    IStopInfo,
    IStopLocations,
    IStopPassage,
    IStopPointLocations,
    ITripPassages,
    IVehicleLocationList,
    IVehiclePathInfo,
    RouteId,
    StopId,
    TripId,
    VehicleId,
} from '@donmahallem/trapeze-api-types';
import * as req from 'request';
import * as reqp from 'request-promise-native';
import UserAgent = require('user-agents');
import { Util } from './util';

let ua: typeof UserAgent;
try {
    // tslint:disable-next-line:no-var-requires
    ua = require('user-agents');
} catch (e) { }
export type StopMode = 'arrival' | 'departure';
export type PositionType = 'CORRECTED' | 'RAW';
export interface IBoundingBox {
    top: number;
    bottom: number;
    left: number;
    right: number;
}
export class TrapezeApiClient {
    private httpClient: req.RequestAPI<reqp.RequestPromise<any>, reqp.RequestPromiseOptions, req.UriOptions>;
    /**
     *
     * @param endpoint the endpoint base Url to query
     * @since 1.0.0
     */
    public constructor(public readonly endpoint: string, public readonly proxies?: string | string[]) {
        this.httpClient = reqp.defaults({
            baseUrl: endpoint,
            headers: {
                'User-Agent': 'Request-Promise: ' + Math.random(),
            },
            json: true,
            proxy: (typeof proxies === 'string') ? proxies : undefined,
        });
    }

    public getProxy(): string | undefined {
        if (typeof this.proxies === 'string') {
            return this.proxies;
        } else if (Array.isArray(this.proxies)) {
            return this.proxies[Math.floor(Math.random() * this.proxies.length)];
        }
        return undefined;
    }

    public request<T>(reqOpts: req.OptionsWithUri): reqp.RequestPromise<T> {
        Object.assign(reqOpts, {
            proxy: this.getProxy(),
        });
        // tslint:disable-next-line:triple-equals
        if (reqOpts.headers == undefined) {
            reqOpts.headers = {};
        }
        const userAgent: string = (ua === undefined) ? 'Trapeze Client Node' : new ua().toString();
        Object.assign(reqOpts.headers, {
            'User-Agent': userAgent,
        });
        return this.httpClient(reqOpts);
    }

    /**
     * @since 1.0.0
     */
    /**
     * Correct
     * @param positionType coordinate type
     * @param lastUpdate timestamp of last update
     */
    public getVehicleLocations(positionType: PositionType = 'CORRECTED',
        lastUpdate?: string | number)
        : reqp.RequestPromise<IVehicleLocationList> {
        const options: req.OptionsWithUri = {
            method: 'GET',
            qs: {
                colorType: 'ROUTE_BASED',
                lastUpdate,
                positionType,
            },
            uri: '/internetservice/geoserviceDispatcher/services/vehicleinfo/vehicles',
        };
        return this.request(options);
    }
    /**
     *
     * @param tripId tripId to query
     * @since 1.0.0
     */
    public getRouteByTripId(tripId: TripId): reqp.RequestPromise<IVehiclePathInfo> {
        const options: req.OptionsWithUri = {
            method: 'POST',
            qs: {
                id: tripId,
            },
            uri: '/internetservice/geoserviceDispatcher/services/pathinfo/trip',
        };
        return this.request(options);
    }
    /**
     *
     * @param vehicleId the vehicleId
     * @since 1.0.0
     */
    public getRouteByVehicleId(vehicleId: VehicleId): reqp.RequestPromise<IVehiclePathInfo> {
        const options: req.OptionsWithUri = {
            method: 'POST',
            qs: {
                id: vehicleId,
            },
            uri: '/internetservice/geoserviceDispatcher/services/pathinfo/vehicle',
        };
        return this.request(options);
    }

    /**
     *
     * @param routeId the route id
     * @since 3.0.0
     */
    public getRouteByRouteId(routeId: RouteId, direction: string): reqp.RequestPromise<IVehiclePathInfo> {
        const options: req.OptionsWithUri = {
            method: 'POST',
            qs: {
                direction,
                id: routeId,
            },
            uri: '/internetservice/geoserviceDispatcher/services/pathinfo/route',
        };
        return this.request(options);
    }

    /**
     *
     * @since 1.4.0
     */
    public getStopLocations(box: IBoundingBox = {
        bottom: -324000000,
        left: -648000000,
        right: 648000000,
        top: 324000000,
    }): reqp.RequestPromise<IStopLocations> {
        const options: req.OptionsWithUri = {
            method: 'GET',
            qs: box,
            uri: '/internetservice/geoserviceDispatcher/services/stopinfo/stops',
        };
        return this.request(options);
    }

    /**
     *
     * @since 1.4.0
     */
    public getStopPointLocations(box: IBoundingBox = {
        bottom: -324000000,
        left: -648000000,
        right: 648000000,
        top: 324000000,
    }): reqp.RequestPromise<IStopPointLocations> {
        const options: req.OptionsWithUri = {
            method: 'GET',
            qs: box,
            uri: '/internetservice/geoserviceDispatcher/services/stopinfo/stopPoints',
        };
        return this.request(options);
    }
    /**
     *
     * @since 1.0.0
     */
    public getTripPassages(tripId: TripId,
        mode: StopMode = 'departure'): reqp.RequestPromise<ITripPassages> {
        const options: req.OptionsWithUri = {
            form: {
                mode,
                tripId,
            },
            method: 'POST',
            uri: '/internetservice/services/tripInfo/tripPassages',
        };
        return this.request(options);
    }

    /**
     *
     * @param startTime milliseconds since epoch. now if undefined
     * @param timeFrame time frame from startTime in minutes
     * @since 2.3.0
     */
    public getStopPassages(stopId: StopId,
        mode: StopMode = 'departure',
        startTime?: number,
        timeFrame?: number): reqp.RequestPromise<IStopPassage> {
        const formData: { [key: string]: any } = {
            mode,
            stop: stopId,
        };
        // tslint:disable-next-line:triple-equals
        if (startTime != undefined) {
            Object.assign(formData, { startTime });
        }
        // tslint:disable-next-line:triple-equals
        if (timeFrame != undefined) {
            Object.assign(formData, { timeFrame });
        }
        const options: req.OptionsWithUri = {
            form: formData,
            method: 'POST',
            uri: '/internetservice/services/passageInfo/stopPassages/stop',
        };
        return this.request(options);
    }

    /**
     *
     * @param startTime milliseconds since epoch. now if undefined
     * @param timeFrame time frame from startTime in minutes
     * @since 3.0.0
     */
    public getStopPointPassages(stopId: StopId,
        mode: StopMode = 'departure',
        startTime?: number,
        timeFrame?: number): reqp.RequestPromise<IStopPassage> {
        const formData: { [key: string]: any } = {
            mode,
            stop: stopId,
        };
        // tslint:disable-next-line:triple-equals
        if (startTime != undefined) {
            Object.assign(formData, { startTime });
        }
        // tslint:disable-next-line:triple-equals
        if (timeFrame != undefined) {
            Object.assign(formData, { timeFrame });
        }
        const options: req.OptionsWithUri = {
            form: formData,
            method: 'POST',
            uri: '/internetservice/services/passageInfo/stopPassages/stopPoint',
        };
        return this.request(options);
    }

    /**
     *
     * @since 1.0.0
     */
    public getStopInfo(stopId: StopId,
        mode: StopMode = 'departure'): reqp.RequestPromise<IStopInfo> {
        const options: req.OptionsWithUri = {
            form: {
                mode,
                stop: stopId,
            },
            method: 'POST',
            uri: '/internetservice/services/stopInfo/stop',
        };
        return this.request(options);
    }

    /**
     *
     * @since 1.0.0
     */
    public getStopPointInfo(stopPointId: string,
        mode: StopMode = 'departure'): reqp.RequestPromise<any> {
        const options: req.OptionsWithUri = {
            form: {
                mode,
                stopPoint: stopPointId,
            },
            method: 'POST',
            uri: '/internetservice/services/stopInfo/stopPoint',
        };
        return this.request(options);
    }
    /**
     * @since 1.3.0
     */
    public getSettings(): reqp.RequestPromise<ISettings> {
        const options: reqp.OptionsWithUri = {
            method: 'GET',
            transform: Util.transformSettingsBody,
            uri: this.endpoint + '/internetservice/settings',
        };
        return this.request(options);
    }

}

1	/*!
2	* Source https://github.com/donmahallem/TrapezeApiClientNode
3	*/
4
5	import {
6	ISettings,
7	IStopInfo,
8	IStopLocations,
9	IStopPassage,
10	IStopPointLocations,
11	ITripPassages,
12	IVehicleLocationList,
13	IVehiclePathInfo,
14	RouteId,
15	StopId,
16	TripId,
17	VehicleId,
18	} from '@donmahallem/trapeze-api-types';
19	import * as req from 'request';
20	import * as reqp from 'request-promise-native';	4✔
21	import UserAgent = require('user-agents');
22	import { Util } from './util';	4✔
23
24	let ua: typeof UserAgent;
25	try {	4✔
26	// tslint:disable-next-line:no-var-requires
27	ua = require('user-agents');	4✔
28	} catch (e) { }
29	export type StopMode = 'arrival' \| 'departure';
30	export type PositionType = 'CORRECTED' \| 'RAW';
31	export interface IBoundingBox {
32	top: number;
33	bottom: number;
34	left: number;
35	right: number;
36	}
37	export class TrapezeApiClient {	4✔
38	private httpClient: req.RequestAPI<reqp.RequestPromise<any>, reqp.RequestPromiseOptions, req.UriOptions>;
39	/**
40	*
41	* @param endpoint the endpoint base Url to query
42	* @since 1.0.0
43	*/
44	public constructor(public readonly endpoint: string, public readonly proxies?: string \| string[]) {	428✔
45	this.httpClient = reqp.defaults({	428✔
46	baseUrl: endpoint,
47	headers: {
48	'User-Agent': 'Request-Promise: ' + Math.random(),
49	},
50	json: true,
51	proxy: (typeof proxies === 'string') ? proxies : undefined,	428!
52	});
53	}
54
55	public getProxy(): string \| undefined {
NEW 56	if (typeof this.proxies === 'string') {	×
NEW 57	return this.proxies;	×
NEW 58	} else if (Array.isArray(this.proxies)) {	×
NEW 59	return this.proxies[Math.floor(Math.random() * this.proxies.length)];	×
60	}
NEW 61	return undefined;	×
62	}
63
64	public request<T>(reqOpts: req.OptionsWithUri): reqp.RequestPromise<T> {
NEW 65	Object.assign(reqOpts, {	×
66	proxy: this.getProxy(),
67	});
68	// tslint:disable-next-line:triple-equals
NEW 69	if (reqOpts.headers == undefined) {	×
NEW UNCOV 70	reqOpts.headers = {};	×
71	}
NEW UNCOV 72	const userAgent: string = (ua === undefined) ? 'Trapeze Client Node' : new ua().toString();	×
NEW UNCOV 73	Object.assign(reqOpts.headers, {	×
74	'User-Agent': userAgent,
75	});
NEW UNCOV 76	return this.httpClient(reqOpts);	×
77	}
78
79	/**
80	* @since 1.0.0
81	*/
82	/**
83	* Correct
84	* @param positionType coordinate type
85	* @param lastUpdate timestamp of last update
86	*/
87	public getVehicleLocations(positionType: PositionType = 'CORRECTED',	4✔
88	lastUpdate?: string \| number)
89	: reqp.RequestPromise<IVehicleLocationList> {
90	const options: req.OptionsWithUri = {	28✔
91	method: 'GET',
92	qs: {
93	colorType: 'ROUTE_BASED',
94	lastUpdate,
95	positionType,
96	},
97	uri: '/internetservice/geoserviceDispatcher/services/vehicleinfo/vehicles',
98	};
99	return this.request(options);	28✔
100	}
101	/**
102	*
103	* @param tripId tripId to query
104	* @since 1.0.0
105	*/
106	public getRouteByTripId(tripId: TripId): reqp.RequestPromise<IVehiclePathInfo> {
107	const options: req.OptionsWithUri = {	8✔
108	method: 'POST',
109	qs: {
110	id: tripId,
111	},
112	uri: '/internetservice/geoserviceDispatcher/services/pathinfo/trip',
113	};
114	return this.request(options);	8✔
115	}
116	/**
117	*
118	* @param vehicleId the vehicleId
119	* @since 1.0.0
120	*/
121	public getRouteByVehicleId(vehicleId: VehicleId): reqp.RequestPromise<IVehiclePathInfo> {
122	const options: req.OptionsWithUri = {	8✔
123	method: 'POST',
124	qs: {
125	id: vehicleId,
126	},
127	uri: '/internetservice/geoserviceDispatcher/services/pathinfo/vehicle',
128	};
129	return this.request(options);	8✔
130	}
131
132	/**
133	*
134	* @param routeId the route id
135	* @since 3.0.0
136	*/
137	public getRouteByRouteId(routeId: RouteId, direction: string): reqp.RequestPromise<IVehiclePathInfo> {
138	const options: req.OptionsWithUri = {	16✔
139	method: 'POST',
140	qs: {
141	direction,
142	id: routeId,
143	},
144	uri: '/internetservice/geoserviceDispatcher/services/pathinfo/route',
145	};
146	return this.request(options);	16✔
147	}
148
149	/**
150	*
151	* @since 1.4.0
152	*/
153	public getStopLocations(box: IBoundingBox = {	4✔
154	bottom: -324000000,
155	left: -648000000,
156	right: 648000000,
157	top: 324000000,
158	}): reqp.RequestPromise<IStopLocations> {
159	const options: req.OptionsWithUri = {	8✔
160	method: 'GET',
161	qs: box,
162	uri: '/internetservice/geoserviceDispatcher/services/stopinfo/stops',
163	};
164	return this.request(options);	8✔
165	}
166
167	/**
168	*
169	* @since 1.4.0
170	*/
171	public getStopPointLocations(box: IBoundingBox = {	4✔
172	bottom: -324000000,
173	left: -648000000,
174	right: 648000000,
175	top: 324000000,
176	}): reqp.RequestPromise<IStopPointLocations> {
177	const options: req.OptionsWithUri = {	8✔
178	method: 'GET',
179	qs: box,
180	uri: '/internetservice/geoserviceDispatcher/services/stopinfo/stopPoints',
181	};
182	return this.request(options);	8✔
183	}
184	/**
185	*
186	* @since 1.0.0
187	*/
188	public getTripPassages(tripId: TripId,
189	mode: StopMode = 'departure'): reqp.RequestPromise<ITripPassages> {	8✔
190	const options: req.OptionsWithUri = {	24✔
191	form: {
192	mode,
193	tripId,
194	},
195	method: 'POST',
196	uri: '/internetservice/services/tripInfo/tripPassages',
197	};
198	return this.request(options);	24✔
199	}
200
201	/**
202	*
203	* @param startTime milliseconds since epoch. now if undefined
204	* @param timeFrame time frame from startTime in minutes
205	* @since 2.3.0
206	*/
207	public getStopPassages(stopId: StopId,
208	mode: StopMode = 'departure',	8✔
209	startTime?: number,
210	timeFrame?: number): reqp.RequestPromise<IStopPassage> {
211	const formData: { [key: string]: any } = {	152✔
212	mode,
213	stop: stopId,
214	};
215	// tslint:disable-next-line:triple-equals
216	if (startTime != undefined) {	152✔
217	Object.assign(formData, { startTime });	48✔
218	}
219	// tslint:disable-next-line:triple-equals
220	if (timeFrame != undefined) {	152✔
221	Object.assign(formData, { timeFrame });	48✔
222	}
223	const options: req.OptionsWithUri = {	152✔
224	form: formData,
225	method: 'POST',
226	uri: '/internetservice/services/passageInfo/stopPassages/stop',
227	};
228	return this.request(options);	152✔
229	}
230
231	/**
232	*
233	* @param startTime milliseconds since epoch. now if undefined
234	* @param timeFrame time frame from startTime in minutes
235	* @since 3.0.0
236	*/
237	public getStopPointPassages(stopId: StopId,
238	mode: StopMode = 'departure',	8✔
239	startTime?: number,
240	timeFrame?: number): reqp.RequestPromise<IStopPassage> {
241	const formData: { [key: string]: any } = {	152✔
242	mode,
243	stop: stopId,
244	};
245	// tslint:disable-next-line:triple-equals
246	if (startTime != undefined) {	152✔
247	Object.assign(formData, { startTime });	48✔
248	}
249	// tslint:disable-next-line:triple-equals
250	if (timeFrame != undefined) {	152✔
251	Object.assign(formData, { timeFrame });	48✔
252	}
253	const options: req.OptionsWithUri = {	152✔
254	form: formData,
255	method: 'POST',
256	uri: '/internetservice/services/passageInfo/stopPassages/stopPoint',
257	};
258	return this.request(options);	152✔
259	}
260
261	/**
262	*
263	* @since 1.0.0
264	*/
265	public getStopInfo(stopId: StopId,
266	mode: StopMode = 'departure'): reqp.RequestPromise<IStopInfo> {	×
NEW UNCOV 267	const options: req.OptionsWithUri = {	×
268	form: {
269	mode,
270	stop: stopId,
271	},
272	method: 'POST',
273	uri: '/internetservice/services/stopInfo/stop',
274	};
NEW 275	return this.request(options);	×
276	}
277
278	/**
279	*
280	* @since 1.0.0
281	*/
282	public getStopPointInfo(stopPointId: string,
283	mode: StopMode = 'departure'): reqp.RequestPromise<any> {	8✔
284	const options: req.OptionsWithUri = {	24✔
285	form: {
286	mode,
287	stopPoint: stopPointId,
288	},
289	method: 'POST',
290	uri: '/internetservice/services/stopInfo/stopPoint',
291	};
292	return this.request(options);	24✔
293	}
294	/**
295	* @since 1.3.0
296	*/
297	public getSettings(): reqp.RequestPromise<ISettings> {
NEW UNCOV 298	const options: reqp.OptionsWithUri = {	×
299	method: 'GET',
300	transform: Util.transformSettingsBody,
301	uri: this.endpoint + '/internetservice/settings',
302	};
NEW UNCOV 303	return this.request(options);	×
304	}
305
306	}

donmahallem / TrapezeApiClientNode / 1196

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