1194

pending completion

Build # 1194

Build Type

Pull #275

travis-ci-com

Committed by

web-flow

Commit Message

fix package-lock missing entries

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

Run Details

8 of 32 branches covered (25.0%)

Branch coverage included in aggregate %.

25 of 48 new or added lines in 3 files covered. (52.08%)

8 existing lines in 1 file now uncovered.

29 of 60 relevant lines covered (48.33%)

13.47 hits per line

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

29.49

/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(top: number = 324000000,
        bottom: number = -324000000,
        left: number = -648000000,
        right: number = 648000000): reqp.RequestPromise<IStopPointLocations> {
        const options: req.OptionsWithUri = {
            method: 'POST',
            qs: {
                bottom,
                left,
                right,
                top,
            },
            uri: '/internetservice/geoserviceDispatcher/services/stopinfo/stopPoints',
        };
        return this.request(options);
    }
    /**
     *
     * @since 1.0.0
     */
    public getTripPassages(tripId: TripId,
        mode: StopMode): 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 options: req.OptionsWithUri = {
            form: {
                mode,
                stop: stopId,
            },
            method: 'POST',
            uri: '/internetservice/services/passageInfo/stopPassages/stop',
        };
        if (startTime) {
            Object.assign(options.form, { startTime });
        }
        if (timeFrame) {
            Object.assign(options.form, { timeFrame });
        }
        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 options: req.OptionsWithUri = {
            form: {
                mode,
                stop: stopId,
            },
            method: 'POST',
            uri: '/internetservice/services/passageInfo/stopPassages/stopPoint',
        };
        if (startTime) {
            Object.assign(options.form, { startTime });
        }
        if (timeFrame) {
            Object.assign(options.form, { timeFrame });
        }
        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[]) {	88✔
45	this.httpClient = reqp.defaults({	88✔
46	baseUrl: endpoint,
47	headers: {
48	'User-Agent': 'Request-Promise: ' + Math.random(),
49	},
50	json: true,
51	proxy: (typeof proxies === 'string') ? proxies : undefined,	88!
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 70	reqOpts.headers = {};	×
71	}
NEW 72	const userAgent: string = (ua === undefined) ? 'Trapeze Client Node' : new ua().toString();	×
NEW 73	Object.assign(reqOpts.headers, {	×
74	'User-Agent': userAgent,
75	});
NEW 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(top: number = 324000000,	×
172	bottom: number = -324000000,	×
173	left: number = -648000000,	×
174	right: number = 648000000): reqp.RequestPromise<IStopPointLocations> {	×
NEW 175	const options: req.OptionsWithUri = {	×
176	method: 'POST',
177	qs: {
178	bottom,
179	left,
180	right,
181	top,
182	},
183	uri: '/internetservice/geoserviceDispatcher/services/stopinfo/stopPoints',
184	};
NEW 185	return this.request(options);	×
186	}
187	/**
188	*
189	* @since 1.0.0
190	*/
191	public getTripPassages(tripId: TripId,
192	mode: StopMode): reqp.RequestPromise<ITripPassages> {
NEW 193	const options: req.OptionsWithUri = {	×
194	form: {
195	mode,
196	tripId,
197	},
198	method: 'POST',
199	uri: '/internetservice/services/tripInfo/tripPassages',
200	};
NEW 201	return this.request(options);	×
202	}
203
204	/**
205	*
206	* @param startTime milliseconds since epoch. now if undefined
207	* @param timeFrame time frame from startTime in minutes
208	* @since 2.3.0
209	*/
210	public getStopPassages(stopId: StopId,
211	mode: StopMode = 'departure',	×
212	startTime?: number,
213	timeFrame?: number): reqp.RequestPromise<IStopPassage> {
NEW 214	const options: req.OptionsWithUri = {	×
215	form: {
216	mode,
217	stop: stopId,
218	},
219	method: 'POST',
220	uri: '/internetservice/services/passageInfo/stopPassages/stop',
221	};
UNCOV 222	if (startTime) {	×
UNCOV 223	Object.assign(options.form, { startTime });	×
224	}
UNCOV 225	if (timeFrame) {	×
UNCOV 226	Object.assign(options.form, { timeFrame });	×
227	}
NEW 228	return this.request(options);	×
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',	×
239	startTime?: number,
240	timeFrame?: number): reqp.RequestPromise<IStopPassage> {
NEW 241	const options: req.OptionsWithUri = {	×
242	form: {
243	mode,
244	stop: stopId,
245	},
246	method: 'POST',
247	uri: '/internetservice/services/passageInfo/stopPassages/stopPoint',
248	};
UNCOV 249	if (startTime) {	×
UNCOV 250	Object.assign(options.form, { startTime });	×
251	}
UNCOV 252	if (timeFrame) {	×
UNCOV 253	Object.assign(options.form, { timeFrame });	×
254	}
NEW 255	return this.request(options);	×
256	}
257
258	/**
259	*
260	* @since 1.0.0
261	*/
262	public getStopInfo(stopId: StopId,
263	mode: StopMode = 'departure'): reqp.RequestPromise<IStopInfo> {	×
NEW 264	const options: req.OptionsWithUri = {	×
265	form: {
266	mode,
267	stop: stopId,
268	},
269	method: 'POST',
270	uri: '/internetservice/services/stopInfo/stop',
271	};
NEW 272	return this.request(options);	×
273	}
274
275	/**
276	*
277	* @since 1.0.0
278	*/
279	public getStopPointInfo(stopPointId: string,
280	mode: StopMode = 'departure'): reqp.RequestPromise<any> {	4✔
281	const options: req.OptionsWithUri = {	20✔
282	form: {
283	mode,
284	stopPoint: stopPointId,
285	},
286	method: 'POST',
287	uri: '/internetservice/services/stopInfo/stopPoint',
288	};
289	return this.request(options);	20✔
290	}
291	/**
292	* @since 1.3.0
293	*/
294	public getSettings(): reqp.RequestPromise<ISettings> {
NEW 295	const options: reqp.OptionsWithUri = {	×
296	method: 'GET',
297	transform: Util.transformSettingsBody,
298	uri: this.endpoint + '/internetservice/settings',
299	};
NEW 300	return this.request(options);	×
301	}
302
303	}

donmahallem / TrapezeApiClientNode / 1194

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