@iotize/tap
Version:
IoTize Device client for Javascript
1,001 lines (985 loc) • 43.8 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@iotize/tap/protocol/core'), require('rxjs'), require('rxjs/operators'), require('@iotize/common/debug'), require('@iotize/common/byte-converter'), require('@iotize/tap/client/api'), require('@iotize/tap/client/impl'), require('@iotize/common/promise'), require('@iotize/tap'), require('@iotize/tap/service/core')) :
typeof define === 'function' && define.amd ? define('@iotize/tap/testing', ['exports', '@iotize/tap/protocol/core', 'rxjs', 'rxjs/operators', '@iotize/common/debug', '@iotize/common/byte-converter', '@iotize/tap/client/api', '@iotize/tap/client/impl', '@iotize/common/promise', '@iotize/tap', '@iotize/tap/service/core'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.iotize = global.iotize || {}, global.iotize.tap = global.iotize.tap || {}, global.iotize.tap.testing = {}), global.iotize.tap.protocol.core, global.rxjs, global.rxjs.operators, global.debug$1, global.byteConverter, global.iotize.tap.client.api, global.iotize.tap.client.impl, global.promise, global.iotize.tap));
})(this, (function (exports, core, rxjs, operators, debug$1, byteConverter, api, impl, promise, tap) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter$1(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
var prefix = '@iotize/tap/testing';
var debug = debug$1.createDebugger(prefix);
var MockRouter = /** @class */ (function () {
function MockRouter() {
this._routes = [];
}
Object.defineProperty(MockRouter.prototype, "routes", {
// constructor() {
// this._routes = [];
// }
get: function () {
return this._routes;
},
enumerable: false,
configurable: true
});
MockRouter.prototype.findRoute = function (request) {
var candidates = this._routes.filter(function (r) { return r.predicate(request); });
if (candidates.length === 0) {
return undefined;
}
else {
return candidates[0].adapter(request);
}
};
// addRoutes(map: RouteMapping) {
// // throw new Error('Method not implemented.');
// // TODO
// }
MockRouter.prototype.addRoute = function (predicate, adapter) {
// var filter: Predicate<Command>;
// if (typeof left === 'string') {
// left = Util.parseApiRequestString(left);
// }
// if (left instanceof ApiRequest) {
// filter = new EqualRequestFilter(left);
// } else if (left instanceof RegExp) {
// filter = new RegExpFilter(left);
// } else if (typeof left === 'function') {
// filter = {
// test: left
// };
// } else {
// filter = left as Predicate<Command>;
// }
// var adapter: ResponseAdapter<T>;
// if (right instanceof ResponseImpl) {
// adapter = new (class Tmp implements ResponseAdapter<T> {
// public adapt(command: Command) {
// return right;
// }
// })();
// } else if (right instanceof Uint8Array) {
// adapter = new (class Tmp implements ResponseAdapter<T> {
// public adapt(command: Command) {
// return new ResponseImpl<T>(right);
// }
// })();
// } else if (typeof right === 'function') {
// adapter = {
// adapt: right
// };
// } else {
// adapter = right as ResponseAdapter<T>;
// }
this._routes.push({
predicate: predicate,
adapter: adapter,
});
return this;
};
// /**
// * Mapping a command (represented as a string with format "<request-type> <path> [data]"
// * ie: GET /3//3 0xABCD or POST /1024//0 0xtest
// *
// * TapResponse must either be:
// * - an hexadecimal data represented as a string (0xABCD)
// * - An object with a coreRet and a body
// * - A Uint8Array
// */
// addRoutes(map: { [key: string]: RouteType }): this {
// for (const pathString in map) {
// const info = map[pathString];
// const command: Command = Util.parseApiRequestString(pathString);
// let response;
// if (info instanceof Uint8Array) {
// response = new ResponseImpl(info);
// } else if (info instanceof ResponseImpl) {
// response = info;
// } else if (typeof info === 'number') {
// response = ResponseImpl.create(info);
// } else if (typeof info === 'string') {
// response = new ResponseImpl(
// hexStringToBuffer(info)
// );
// } else if (typeof info === 'object') {
// const codeRet: number = (info as RouteTypeObject).codeRet;
// response = new ResponseImpl(
// KaitaiStreamWriter.mergeArrays(
// Uint8Array.from([codeRet]),
// (info as RouteTypeObject).body || new Uint8Array(0)
// )
// );
// } else {
// throw new Error(
// `Invalid response type ${typeof info} with value: ${JSON.stringify(
// info
// )}`
// );
// }
// debug(TAG, `\t- Add map ${command} -> ${response}`);
// this.addRoute(command, response);
// }
// return this;
// }
MockRouter.prototype.clearRoutes = function () {
this._routes = [];
return this;
};
return MockRouter;
}());
// /**
// * @deprecated in favor of {@link #addRoute}
// */
// public mapResponse<T>(
// left:
// | FilterFunction<TapRequestFrame>
// | Predicate<TapRequestFrame>
// | TapRequestFrame,
// right:
// | ResponseAdapterFunction<T>
// | ResponseAdapter<T>
// | TapResponse<T>
// | Uint8Array
// ): this {
// return this.addRoute(left, right);
// }
// public addRoute<T>(
// left:
// | FilterFunction<TapRequestFrame>
// | Predicate<TapRequestFrame>
// | TapRequestFrame,
// right:
// | ResponseAdapterFunction<T>
// | ResponseAdapter<T>
// | TapResponse<T>
// | Uint8Array
// ): this {
// this.router.addRoute(left, right);
// return this;
// }
// // public Configuration getConfiguration() {
// // return configuration;
// // }
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try {
step(generator.next(value));
}
catch (e) {
reject(e);
} }
function rejected(value) { try {
step(generator["throw"](value));
}
catch (e) {
reject(e);
} }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var TAG$1 = 'MockProtocol';
function createMockProtocol() {
return new MockProtocol();
}
/**
*
* <p>
* This is a mock com protocol for testing only
* <p>
* We can simulate iotize response according to the request message
*/
var MockProtocol = /** @class */ (function (_super) {
__extends(MockProtocol, _super);
function MockProtocol() {
var _this = _super.call(this) || this;
_this.mockOptions = {
connect: {
delay: 100,
},
disconnect: {
delay: 100,
},
write: {
delay: 1,
},
};
_this.input = new rxjs.Subject();
_this.output = new rxjs.Subject();
_this._router = new MockRouter();
return _this;
// this.connectDelay = 2000;
// this.disconnectDelay = 2000;
// this.callback = callback;
// this.lastReceivedData = new Uint8Array(0);
// this.configuration = new Configuration();
// this.configuration.connectionTimeoutMillis = 3000;
// this.configuration.sendTimeoutMillis = 3000;
}
MockProtocol.MIRROR = function () {
var mockProtocol = new MockProtocol();
mockProtocol.input.subscribe(function (input) {
mockProtocol.setOutputData(input);
});
// mockProtocol.router.addRoute(
// (command: Uint8Array) => {
// return true;
// },
// (request: Uint8Array) => {
// return request;
// }
// );
return mockProtocol;
};
// /**
// * Create a new instance from roote mapping
// */
// public static createFromRoutes(map: RouteMapping): MockProtocol {
// const mockProtocol = new MockProtocol();
// mockProtocol.router.addRoutes(map);
// return mockProtocol;
// }
// public get router(): MockRouter {
// return this._router;
// }
MockProtocol.prototype.setConnectionState = function (connectionState) {
debug(TAG$1, "setConnectionState: " + connectionState);
this.connectionState = connectionState;
return this;
};
MockProtocol.prototype.setConnectDelay = function (connectDelay) {
this.mockOptions.connect.delay = connectDelay;
return this;
};
MockProtocol.prototype.getDisconnectDelay = function () {
return this.mockOptions.disconnect.delay;
};
MockProtocol.prototype.setDisconnectDelay = function (disconnectDelay) {
this.mockOptions.disconnect.delay = disconnectDelay;
return this;
};
MockProtocol.prototype.setOutputData = function (inputData) {
this.lastTranseiveData = inputData;
this.output.next(inputData);
};
MockProtocol.prototype.setInputData = function (outputData) {
this.lastReceivedData = outputData;
this.input.next(outputData);
};
MockProtocol.prototype.setCallback = function (callback) {
this.callback = callback;
};
MockProtocol.prototype._connect = function (options) {
return rxjs.of(undefined).pipe(operators.delay(this.mockOptions.connect.delay));
};
MockProtocol.prototype._disconnect = function (options) {
return rxjs.of(undefined).pipe(operators.delay(this.mockOptions.disconnect.delay));
};
MockProtocol.prototype.write = function (request) {
return __awaiter(this, void 0, void 0, function () {
var err_1;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 5, , 6]);
if (!this.callback) return [3 /*break*/, 2];
return [4 /*yield*/, this.callback.beforeWrite(request)];
case 1:
_a.sent();
_a.label = 2;
case 2:
// this.lastReceivedData = request;
// const response = this.router.findRoute(request);
// if (!response) {
// throw new Error(`Not route for request ${bufferToHexString(request)}`)
// }
// debug(
// TAG,
// 'MockProtocol',
// 'Mocking response for ' + request + ' => ' + response
// );
// var result = this.responseEncoder.encode(response);
this.setInputData(request);
if (!this.callback) return [3 /*break*/, 4];
return [4 /*yield*/, this.callback.afterWrite(request)];
case 3:
_a.sent();
_a.label = 4;
case 4: return [2 /*return*/, new Promise(function (resolve) { return setTimeout(resolve, _this.mockOptions.write.delay); })];
case 5:
err_1 = _a.sent();
return [2 /*return*/, new Promise(function (resolve, reject) { return setTimeout(function () { return reject(err_1); }, _this.mockOptions.write.delay); })];
case 6: return [2 /*return*/];
}
});
});
};
MockProtocol.prototype.read = function () {
try {
if (this.callback) {
this.callback.beforeRead();
}
return this.output
.pipe(operators.first())
.toPromise()
.then(function (v) { return (v ? v : new Uint8Array()); });
// while (!this.hasNewData()) {
// // TODO wait ??
// }
// if (this.lastTranseiveData) {
// const result = of(this.lastTranseiveData);
// if (this.callback) {
// this.callback.afterRead(result);
// }
// return result.toPromise();
// } else {
// return Promise.reject(new Error('Read timeout'));
// }
}
catch (err) {
return Promise.reject(err);
}
};
return MockProtocol;
}(core.QueueComProtocol));
// public addOnRequestListener() {
// this.mOnRequestListener =
// }
// public interface onRequestListener{
// onRequest(RequestMessage request);
// }
var TAP_REQUEST_STRING_REGEX = /^(GET|PUT|POST)\s+(\/[0-9]+\/[0-9]*\/[0-9]+)\s?(\s+(0x[a-zA-Z0-9]+))?$/i;
function createTapRequestFromString(request) {
var match = TAP_REQUEST_STRING_REGEX.exec(request);
if (match) {
var methodType = match[1];
var path = match[2];
var body = match[4] ? byteConverter.hexStringToBuffer(match[4]) : undefined;
return impl.TapRequestFrameBuilder.create(api.TapRequestFrame.MethodType[methodType], path, body);
}
else {
throw new Error("Invalid tap request string format: \"" + request + "\".");
}
}
var tapRequestEqualFilter = function (expectedRequest) {
return function (request) {
return (impl.TapRequestHelper.toString(expectedRequest) ===
impl.TapRequestHelper.toString(request));
};
};
var ɵ0 = tapRequestEqualFilter;
var TAG = 'MockClient';
function createMockClient(options) {
return new MockClient({
isConnected: !!(options === null || options === void 0 ? void 0 : options.connected),
});
}
var MockClient = /** @class */ (function (_super) {
__extends(MockClient, _super);
function MockClient(options, router) {
if (options === void 0) { options = {}; }
if (router === void 0) { router = new MockRouter(); }
var _this = _super.call(this, new impl.TapApduRequestConverter(), new impl.TapApduResponseConverter()) || this;
_this.router = router;
_this.input = new rxjs.Subject();
_this.output = new rxjs.Subject();
_this.options = Object.assign(Object.assign({}, MockClient.DEFAULT_OPTIONS), options);
return _this;
}
MockClient.prototype.isConnected = function () {
return this.options.isConnected;
};
// /**
// *
// * TOPO add support for parameters ?
// * TODO use Shell Grammar instead ?
// *
// * @param map
// */
// public static createFromMap(map: MappingType): MockClient {
// const client = new MockClient();
// client.addRoutes(map);
// return client;
// }
MockClient.createWithMockProtocol = function () {
var client = new MockClient({
isConnected: false,
});
client.addComProtocol(createMockProtocol());
return client;
};
MockClient.prototype.connect = function () {
var _this = this;
var observable = rxjs.of(undefined).pipe(operators.delay(this.options.connect.delay));
observable.subscribe(function () {
_this.options.isConnected = true;
});
return observable;
};
MockClient.prototype.disconnect = function () {
var _this = this;
var observable = rxjs.of(undefined).pipe(operators.delay(this.options.disconnect.delay));
observable.subscribe(function () {
_this.options.isConnected = false;
});
return observable;
};
MockClient.prototype.mockResponse = function (tapResponse) {
this.output.next(tapResponse);
};
MockClient.prototype.request = function (request) {
if (!this.isConnected()) {
return rxjs.throwError(impl.TapClientError.notConnectedError());
}
var responseP = this.output
.pipe(
// tap(event => console.log('EVENT', event)),
operators.first(), operators.delay(this.options.command.delay), operators.timeout(this.options.command.timeout))
.toPromise();
this.input.next(request);
return rxjs.from(responseP);
};
// /**
// * @deprecated in favor of addRoute
// * @param cmd
// * @param response
// */
// public mapCommandToResponse(cmd: Command, response: TapResponse<any>) {
// return this.addRoute(cmd, response);
// }
// public addRoute<T>(
// command: Command | string | RegExp | TapRequestFilter,
// response: ResponseMapType
// ): this {
// debug(
// TAG,
// `\t- Mapping command ${command.toString()} to response ${response.toString()}`
// );
// if (command instanceof RegExp) {
// throw new Error(
// `Route with regular expressions are not implemented yet`
// );
// } else if (typeof command === 'string') {
// command = Util.parseApiRequestString(command);
// }
// this.router.addRoute(
// command,
// this.createResponse(command, response)
// );
// return this;
// }
// public addRoutes(map: MappingType): this {
// for (const pathString in map) {
// const info = map[pathString];
// const command: Command = Util.parseApiRequestString(pathString);
// const response = this.createResponse(command, info);
// this.addRoute(command, response);
// }
// return this;
// }
// public hasRoute(command: Command | string): boolean {
// if (typeof command === 'string') {
// command = Util.parseApiRequestString(command);
// }
// return this.router.findRoute(command) != undefined;
// }
// createResponse<T>(
// command: Command | TapRequestFilter,
// info: ResponseMapType
// ): TapResponse<T> | ResponseAdapterFunction<any> {
// let response: TapResponse<T>;
// if (typeof info === 'number') {
// response = TapResponse.create(info);
// } else if (typeof info === 'string') {
// response = new TapResponse(hexStringToBuffer(info));
// } else if (typeof info === 'object') {
// if (info instanceof TapResponse) {
// response = info;
// } else {
// response = TapResponse.create(typeof info.codeRet === 'number' ? info.codeRet : info.status);
// (response as TapResponse<T>).setBody(info.body);
// }
// } else if (typeof info === 'function') {
// if (command instanceof ApiRequest) {
// response = info(command);
// } else {
// return (command: TapRequestFrame) => {
// const response = info(command);
// if (response instanceof ResponseImpl) {
// response.setRequest(command);
// }
// return response;
// };
// }
// } else {
// throw new Error(
// `Invalid payload type from key ${command.toString()}`
// );
// }
// if (command instanceof ApiRequest && response instanceof ResponseImpl) {
// response.setRequest(command);
// }
// return response;
// }
MockClient.prototype.computeResponse = function (cmd) {
var response = this.router.findRoute(cmd);
if (response) {
return response;
}
else {
debug(TAG, "MockClient", "command " + cmd + " has not been mapped. Returning 404 not found");
return impl.TapResponseFrameBuilder.ERROR(api.ResultCode.NOT_FOUND);
}
};
return MockClient;
}(impl.TapClient));
MockClient.DEFAULT_OPTIONS = {
isConnected: false,
connect: {
delay: 100,
},
disconnect: {
delay: 100,
},
command: {
delay: 100,
timeout: 500,
},
encryption: true,
};
function createMockServiceFunctionCustom(responseBuilder, options) {
if (options === void 0) { options = {
responseDelay: 10,
}; }
return function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
return promise.promiseDelay(responseBuilder.apply(void 0, __spreadArray([], __read(args))), options.responseDelay);
};
}
function createMockServiceFunction(responseStatus, options) {
if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
if (options === void 0) { options = {
responseDelay: 10,
}; }
return function () {
var response = createMockServiceResponse(responseStatus);
return promise.promiseDelay(response, options.responseDelay);
};
}
function createMockServiceFunctionWithBody(responseStatus, body, options) {
if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
if (options === void 0) { options = {
responseDelay: 10,
}; }
return function () {
var response = createMockServiceResponseWithBody(responseStatus, body);
return promise.promiseDelay(response, options.responseDelay);
};
}
function createMockServiceResponse(responseStatus) {
if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
var response = new tap.TapResponse(impl.TapResponseFrameBuilder.create(responseStatus));
return response;
}
function createMockServiceResponseWithBody(responseStatus, body) {
if (responseStatus === void 0) { responseStatus = api.ResultCode.OK; }
var response = new tap.TapResponse(impl.TapResponseFrameBuilder.create(responseStatus));
if (body instanceof Uint8Array) {
response['_tapResponse'].data = body;
}
if (body) {
response.setBody(body);
}
return response;
}
function createMockServiceResponseError(code) {
var response = new tap.TapResponse(impl.TapResponseFrameBuilder.ERROR(code));
return response;
}
function createMockService(constructorFct) {
var serviceCallRunnner = new MockServiceCallRunner();
return new constructorFct(serviceCallRunnner);
}
var MockServiceCallRunner = /** @class */ (function (_super) {
__extends(MockServiceCallRunner, _super);
// TODO
function MockServiceCallRunner() {
return _super.call(this, new MockClient()) || this;
}
return MockServiceCallRunner;
}(tap.ServiceCallRunner));
function createMockTap(options) {
return new MockTap(options);
}
/**
* @experimental
*/
var MockTap = /** @class */ (function (_super) {
__extends(MockTap, _super);
function MockTap(options) {
return _super.call(this, createMockClient(options)) || this;
}
Object.defineProperty(MockTap.prototype, "client", {
get: function () {
return this._client;
},
enumerable: false,
configurable: true
});
Object.defineProperty(MockTap.prototype, "lwm2m", {
get: function () {
return this._lwm2m;
},
enumerable: false,
configurable: true
});
return MockTap;
}(tap.Tap));
"use strict";
Array.prototype.findSafe = function (predicate) {
var val = this.find(predicate);
if (val === undefined) {
throw new Error("Cannot find element with predicate: " + predicate);
}
return val;
};
/**
* Generated bundle index. Do not edit.
*/
exports.MockClient = MockClient;
exports.MockProtocol = MockProtocol;
exports.MockServiceCallRunner = MockServiceCallRunner;
exports.MockTap = MockTap;
exports.createMockClient = createMockClient;
exports.createMockProtocol = createMockProtocol;
exports.createMockService = createMockService;
exports.createMockServiceFunction = createMockServiceFunction;
exports.createMockServiceFunctionCustom = createMockServiceFunctionCustom;
exports.createMockServiceFunctionWithBody = createMockServiceFunctionWithBody;
exports.createMockServiceResponse = createMockServiceResponse;
exports.createMockServiceResponseError = createMockServiceResponseError;
exports.createMockServiceResponseWithBody = createMockServiceResponseWithBody;
exports.createMockTap = createMockTap;
exports.createTapRequestFromString = createTapRequestFromString;
exports["ɵ0"] = ɵ0;
exports["ɵa"] = MockRouter;
Object.defineProperty(exports, '__esModule', { value: true });
}));
//# sourceMappingURL=iotize-tap-testing.umd.js.map