summaryrefslogtreecommitdiffstats
path: root/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/jaegertracing/thrift/lib/nodets/test/test_handler.ts300
1 files changed, 300 insertions, 0 deletions
diff --git a/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts b/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts
new file mode 100644
index 000000000..996c32a5a
--- /dev/null
+++ b/src/jaegertracing/thrift/lib/nodets/test/test_handler.ts
@@ -0,0 +1,300 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * 'License'); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * 'AS IS' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+//This is the server side Node test handler for the standard
+// Apache Thrift test service.
+
+import ttypes = require("./gen-nodejs/ThriftTest_types");
+import thrift = require("thrift");
+import Thrift = thrift.Thrift;
+import Q = require("q");
+import Int64 = require("node-int64");
+
+
+export class SyncThriftTestHandler {
+ testVoid(): Q.IPromise<void> {
+ //console.log('testVoid()');
+ return Q.resolve<void>(undefined);
+ }
+ testMapMap(hello: number) {
+ //console.log('testMapMap(' + hello + ')');
+
+ var mapmap: {[key: number]: {[key: number]: number; }} = [];
+ var pos: {[key: number]: number; } = [];
+ var neg: {[key: number]: number; } = [];
+ for (var i = 1; i < 5; i++) {
+ pos[i] = i;
+ neg[-i] = -i;
+ }
+ mapmap[4] = pos;
+ mapmap[-4] = neg;
+
+ return Q.resolve(mapmap);
+ }
+ testInsanity(argument: ttypes.Insanity): Q.IPromise<{ [k: number]: any; }> {
+ const first_map: { [k: number]: any; } = [];
+ const second_map: { [k: number]: any; } = [];
+
+ first_map[ttypes.Numberz.TWO] = argument;
+ first_map[ttypes.Numberz.THREE] = argument;
+
+ const looney = new ttypes.Insanity();
+ second_map[ttypes.Numberz.SIX] = looney;
+
+ const insane: { [k: number]: any; } = [];
+ insane[1] = first_map;
+ insane[2] = second_map;
+
+ return Q.resolve(insane);
+ }
+ testMulti(arg0: any, arg1: number, arg2: Int64, arg3: { [k: number]: string; }, arg4: ttypes.Numberz, arg5: number) {
+ var hello = new ttypes.Xtruct();
+ hello.string_thing = 'Hello2';
+ hello.byte_thing = arg0;
+ hello.i32_thing = arg1;
+ hello.i64_thing = arg2;
+ return Q.resolve(hello);
+ }
+ testException(arg: string): Q.IPromise<void> {
+ if (arg === 'Xception') {
+ var x = new ttypes.Xception();
+ x.errorCode = 1001;
+ x.message = arg;
+ throw x;
+ } else if (arg === 'TException') {
+ throw new Thrift.TException(arg);
+ } else {
+ return Q.resolve();
+ }
+ }
+ testMultiException(arg0: string, arg1: string) {
+ if (arg0 === ('Xception')) {
+ var x = new ttypes.Xception();
+ x.errorCode = 1001;
+ x.message = 'This is an Xception';
+ throw x;
+ } else if (arg0 === ('Xception2')) {
+ var x2 = new ttypes.Xception2();
+ x2.errorCode = 2002;
+ x2.struct_thing = new ttypes.Xtruct();
+ x2.struct_thing.string_thing = 'This is an Xception2';
+ throw x2;
+ }
+
+ var res = new ttypes.Xtruct();
+ res.string_thing = arg1;
+ return Q.resolve(res);
+ }
+ testOneway(sleepFor: number) {
+ }
+
+ testString(thing: string) {
+ return Q.resolve(thing);
+ }
+ testBool(thing: boolean) {
+ return Q.resolve(thing);
+ }
+ testByte(thing: number) {
+ return Q.resolve(thing);
+ }
+ testI32(thing: number) {
+ return Q.resolve(thing);
+ }
+ testI64(thing: number) {
+ return Q.resolve(thing);
+ }
+ testDouble(thing: number) {
+ return Q.resolve(thing);
+ }
+ testBinary(thing: Buffer) {
+ return Q.resolve(thing);
+ }
+ testStruct(thing: ttypes.Xtruct) {
+ return Q.resolve(thing);
+ }
+ testNest(thing: ttypes.Xtruct2) {
+ return Q.resolve(thing);
+ }
+ testMap(thing: { [k: number]: number; }) {
+ return Q.resolve(thing);
+ }
+ testStringMap(thing: { [k: string]: string; }) {
+ return Q.resolve(thing);
+ }
+ testSet(thing: number[]) {
+ return Q.resolve(thing);
+ }
+ testList(thing: number[]) {
+ return Q.resolve(thing);
+ }
+ testEnum(thing: ttypes.Numberz) {
+ return Q.resolve(thing);
+ }
+ testTypedef(thing: number) {
+ return Q.resolve(thing);
+ }
+}
+
+export class AsyncThriftTestHandler {
+ private syncHandler: SyncThriftTestHandler;
+ constructor() {
+ this.syncHandler = new SyncThriftTestHandler();
+ }
+
+ testVoid(callback: (result: void) => void): Q.IPromise<void> {
+ callback(undefined);
+ return Q.resolve();
+ }
+ testMapMap(hello: number,
+ callback: (err: any, result: { [k: number]: { [k: number]: number; }; }) => void):
+ Q.IPromise<{ [k: number]: { [k: number]: number; }; }> {
+
+ var mapmap: {[key: number]: {[key: number]: number; }} = [];
+ var pos: {[key: number]: number; } = [];
+ var neg: {[key: number]: number; } = [];
+ for (var i = 1; i < 5; i++) {
+ pos[i] = i;
+ neg[-i] = -i;
+ }
+ mapmap[4] = pos;
+ mapmap[-4] = neg;
+
+ callback(null, mapmap);
+ return Q.resolve();
+ }
+ testInsanity(argument: ttypes.Insanity, callback?: (err: any, result: { [k: number]: any; }) => void): Q.IPromise<{ [k: number]: any; }> {
+ const first_map: { [k: number]: any; } = [];
+ const second_map: { [k: number]: any; } = [];
+
+ first_map[ttypes.Numberz.TWO] = argument;
+ first_map[ttypes.Numberz.THREE] = argument;
+
+ const looney = new ttypes.Insanity();
+ second_map[ttypes.Numberz.SIX] = looney;
+
+ const insane: { [k: number]: any; } = [];
+ insane[1] = first_map;
+ insane[2] = second_map;
+
+ if (callback !== undefined){
+ callback(null, insane);
+ }
+ return Q.resolve();
+ }
+ testMulti(arg0: any, arg1: number, arg2: Int64, arg3: { [k: number]: string; }, arg4: ttypes.Numberz, arg5: number, result: Function): Q.IPromise<ttypes.Xtruct> {
+ var hello = this.syncHandler.testMulti(arg0, arg1, arg2, arg3, arg4, arg5);
+ hello.then(hello => result(null, hello));
+ return Q.resolve();
+ }
+ testException(arg: string, result: (err: any) => void): Q.IPromise<void> {
+ if (arg === 'Xception') {
+ var x = new ttypes.Xception();
+ x.errorCode = 1001;
+ x.message = arg;
+ result(x);
+ } else if (arg === 'TException') {
+ result(new Thrift.TException(arg));
+ } else {
+ result(null);
+ }
+ return Q.resolve();
+ }
+ testMultiException(arg0: string, arg1: string, result: (err: any, res?: ttypes.Xtruct) => void): Q.IPromise<ttypes.Xtruct> {
+ if (arg0 === ('Xception')) {
+ var x = new ttypes.Xception();
+ x.errorCode = 1001;
+ x.message = 'This is an Xception';
+ result(x);
+ } else if (arg0 === ('Xception2')) {
+ var x2 = new ttypes.Xception2();
+ x2.errorCode = 2002;
+ x2.struct_thing = new ttypes.Xtruct();
+ x2.struct_thing.string_thing = 'This is an Xception2';
+ result(x2);
+ } else {
+ var res = new ttypes.Xtruct();
+ res.string_thing = arg1;
+ result(null, res);
+ }
+ return Q.resolve();
+ }
+ testOneway(sleepFor: number, result: Function) {
+ this.syncHandler.testOneway(sleepFor);
+ }
+ testString(thing: string, callback: (err: any, result: string) => void): Q.IPromise<string> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testByte(thing: number, callback: (err: any, result: number) => void): Q.IPromise<number> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testBool(thing: boolean, callback: (err: any, result: boolean) => void ): Q.IPromise<boolean> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testI32(thing: number, callback: (err: any, result: number) => void): Q.IPromise<number> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testI64(thing: number, callback: (err: any, result: number) => void): Q.IPromise<number> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testDouble(thing: number, callback: (err: any, result: number) => void): Q.IPromise<number> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testBinary(thing: Buffer, callback: (err: any, result: Buffer) => void): Q.IPromise<Buffer> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testStruct(thing: ttypes.Xtruct, callback: (err: any, result: ttypes.Xtruct) => void): Q.IPromise<ttypes.Xtruct> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testNest(thing: ttypes.Xtruct2, callback: (err: any, result: ttypes.Xtruct2) => void): Q.IPromise<ttypes.Xtruct2> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testMap(thing: { [k: number]: number; }, callback: (err: any, result: { [k: number]: number; }) => void): Q.IPromise<{ [k: number]: number; }> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testStringMap(thing: { [k: string]: string; }, callback: (err: any, result: { [k: string]: string; }) => void): Q.IPromise<{ [k: string]: string; }> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testSet(thing: number[], callback: (err: any, result: number[]) => void): Q.IPromise<number[]> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testList(thing: number[], callback: (err: any, result: number[]) => void): Q.IPromise<number[]> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testEnum(thing: ttypes.Numberz, callback: (err: any, result: ttypes.Numberz) => void): Q.IPromise<ttypes.Numberz> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+ testTypedef(thing: number, callback: (err: any, result: number) => void): Q.IPromise<number> {
+ callback(null, thing);
+ return Q.resolve();
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-15 23:31:20 +0000