lib/nodets/test/test_driver.ts - thrift - Git at Google

 /*
  * 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 Node.js test driver for the standard Apache Thrift
  // test service. The driver invokes every function defined in the
  // Thrift Test service with a representative range of parameters.
  //
  // The ThriftTestDriver function requires a client object
  // connected to a server hosting the Thrift Test service and
  // supports an optional callback function which is called with
  // a status message when the test is complete.

 import test = require("tape");
 import ttypes = require("./gen-nodejs/ThriftTest_types");
 import ThriftTest = require("./gen-nodejs/ThriftTest");
 import thrift = require("thrift");
 import Q = thrift.Q;
 import TException = thrift.Thrift.TException;
 var Int64 = require("node-int64");
 import testCases = require("./test-cases");

 export function ThriftTestDriver(client: ThriftTest.Client, callback: (status: string) => void) {

   test("NodeJS Style Callback Client Tests", function(assert) {

     var checkRecursively = makeRecursiveCheck(assert);

     function makeAsserter(assertionFn: (a: any, b: any, msg?: string) => void) {
       return function(c: (string | any)[]) {
         var fnName = c[0];
         var expected = c[1];
         (<any>client)[fnName](expected, function(err: any, actual: any) {
           assert.error(err, fnName + ": no callback error");
           assertionFn(actual, expected, fnName);
         })
       };
     }

     testCases.simple.forEach(makeAsserter(assert.equal));
     testCases.simpleLoose.forEach(makeAsserter(function(a, e, m){
       assert.ok(a == e, m);
     }));
     testCases.deep.forEach(makeAsserter(assert.deepEqual));

     client.testMapMap(42, function(err, response) {
       var expected: typeof response = {
         "4": {"1":1, "2":2, "3":3, "4":4},
         "-4": {"-4":-4, "-3":-3, "-2":-2, "-1":-1}
       };
       assert.error(err, 'testMapMap: no callback error');
       assert.deepEqual(expected, response, "testMapMap");
     });

     client.testStruct(testCases.out, function(err, response) {
       assert.error(err, "testStruct: no callback error");
       checkRecursively(testCases.out, response, "testStruct");
     });

     client.testNest(testCases.out2, function(err, response) {
       assert.error(err, "testNest: no callback error");
       checkRecursively(testCases.out2, response, "testNest");
     });

     client.testInsanity(testCases.crazy, function(err, response) {
       assert.error(err, "testInsanity: no callback error");
       checkRecursively(testCases.insanity, response, "testInsanity");
     });

     client.testException("TException", function(err, response) {
       assert.ok(err instanceof TException, 'testException: correct error type');
       assert.ok(!Boolean(response), 'testException: no response');
     });

     client.testException("Xception", function(err, response) {
       assert.ok(err instanceof ttypes.Xception, 'testException: correct error type');
       assert.ok(!Boolean(response), 'testException: no response');
       assert.equal(err.errorCode, 1001, 'testException: correct error code');
       assert.equal('Xception', err.message, 'testException: correct error message');
     });

     client.testException("no Exception", function(err, response) {
       assert.error(err, 'testException: no callback error');
       assert.ok(!Boolean(response), 'testException: no response');
     });

     client.testOneway(0, function(err, response) {
       assert.error(err, 'testOneway: no callback error');
       assert.strictEqual(response, undefined, 'testOneway: void response');
     });

     checkOffByOne(function(done) {
       client.testI32(-1, function(err, response) {
         assert.error(err, "checkOffByOne: no callback error");
         assert.equal(-1, response);
         assert.end();
         done();
       });
     }, callback);

   });
 };

 export function ThriftTestDriverPromise(client: ThriftTest.Client, callback: (status: string) => void) {

   test("Q Promise Client Tests", function(assert) {

     var checkRecursively = makeRecursiveCheck(assert);

     function fail(msg: string) {
       return function(error, response) {
         if (error !== null) {
           assert.fail(msg);
         }
       }
     }

     function makeAsserter(assertionFn: (a: any, b: any, msg?: string) => void) {
       return function(c: (string | any)[]) {
         var fnName = c[0];
         var expected = c[1];
         (<any>client)[fnName](expected)
           .then(function(actual: any) {
             assertionFn(actual, expected, fnName);
           })
           .fail(fail("fnName"));
       };
     }

     testCases.simple.forEach(makeAsserter(assert.equal));
     testCases.simpleLoose.forEach(makeAsserter(function(a, e, m){
       assert.ok(a == e, m);
     }));
     testCases.deep.forEach(makeAsserter(assert.deepEqual));

     Q.resolve(client.testStruct(testCases.out))
       .then(function(response) {
         checkRecursively(testCases.out, response, "testStruct");
       })
       .fail(fail("testStruct"));

     Q.resolve(client.testNest(testCases.out2))
       .then(function(response) {
         checkRecursively(testCases.out2, response, "testNest");
       })
       .fail(fail("testNest"));

     Q.resolve(client.testInsanity(testCases.crazy))
       .then(function(response) {
         checkRecursively(testCases.insanity, response, "testInsanity");
       })
       .fail(fail("testInsanity"));

     Q.resolve(client.testException("TException"))
       .then(function(response) {
         fail("testException: TException");
       })
       .fail(function(err) {
         assert.ok(err instanceof TException);
       });

     Q.resolve(client.testException("Xception"))
       .then(function(response) {
         fail("testException: Xception");
       })
       .fail(function(err) {
         assert.ok(err instanceof ttypes.Xception);
         assert.equal(err.errorCode, 1001);
         assert.equal("Xception", err.message);
       });

     Q.resolve(client.testException("no Exception"))
       .then(function(response) {
         assert.equal(undefined, response); //void
       })
       .fail(fail("testException"));

     client.testOneway(0, fail("testOneway: should not answer"));

     checkOffByOne(function(done) {
       Q.resolve(client.testI32(-1))
         .then(function(response) {
             assert.equal(-1, response);
             assert.end();
             done();
         })
         .fail(fail("checkOffByOne"));
     }, callback);
   });
 };


 // Helper Functions
 // =========================================================

 function makeRecursiveCheck(assert: test.Test) {

   return function (map1: any, map2: any, msg: string) {
     var equal = true;

     var equal = checkRecursively(map1, map2);

     assert.ok(equal, msg);

     // deepEqual doesn't work with fields using node-int64
     function checkRecursively(map1: any, map2: any) : boolean {
       if (!(typeof map1 !== "function" && typeof map2 !== "function")) {
         return false;
       }
       if (!map1 || typeof map1 !== "object") {
         //Handle int64 types (which use node-int64 in Node.js JavaScript)
         if ((typeof map1 === "number") && (typeof map2 === "object") &&
             (map2.buffer) && (map2.buffer instanceof Buffer) && (map2.buffer.length === 8)) {
           var n = new Int64(map2.buffer);
           return map1 === n.toNumber();
         } else {
           return map1 == map2;
         }
       } else {
         return Object.keys(map1).every(function(key) {
           return checkRecursively(map1[key], map2[key]);
         });
       }
     }
   }
 }

 function checkOffByOne(done: (callback: () => void) => void, callback: (message: string) => void) {

   var retry_limit = 30;
   var retry_interval = 100;
   var test_complete = false;
   var retrys = 0;

   /**
    * redo a simple test after the oneway to make sure we aren't "off by one" --
    * if the server treated oneway void like normal void, this next test will
    * fail since it will get the void confirmation rather than the correct
    * result. In this circumstance, the client will throw the exception:
    *
    * Because this is the last test against the server, when it completes
    * the entire suite is complete by definition (the tests run serially).
    */
   done(function() {
     test_complete = true;
   });

   //We wait up to retry_limit * retry_interval for the test suite to complete
   function TestForCompletion() {
     if(test_complete && callback) {
       callback("Server successfully tested!");
     } else {
       if (++retrys < retry_limit) {
         setTimeout(TestForCompletion, retry_interval);
       } else if (callback) {
         callback("Server test failed to complete after " +
                  (retry_limit * retry_interval / 1000) + " seconds");
       }
     }
   }

   setTimeout(TestForCompletion, retry_interval);
 }
	/*
	* 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 Node.js test driver for the standard Apache Thrift
	// test service. The driver invokes every function defined in the
	// Thrift Test service with a representative range of parameters.
	//
	// The ThriftTestDriver function requires a client object
	// connected to a server hosting the Thrift Test service and
	// supports an optional callback function which is called with
	// a status message when the test is complete.

	import test = require("tape");
	import ttypes = require("./gen-nodejs/ThriftTest_types");
	import ThriftTest = require("./gen-nodejs/ThriftTest");
	import thrift = require("thrift");
	import Q = thrift.Q;
	import TException = thrift.Thrift.TException;
	var Int64 = require("node-int64");
	import testCases = require("./test-cases");

	export function ThriftTestDriver(client: ThriftTest.Client, callback: (status: string) => void) {

	test("NodeJS Style Callback Client Tests", function(assert) {

	var checkRecursively = makeRecursiveCheck(assert);

	function makeAsserter(assertionFn: (a: any, b: any, msg?: string) => void) {
	return function(c: (string \| any)[]) {
	var fnName = c[0];
	var expected = c[1];
	(<any>client)[fnName](expected, function(err: any, actual: any) {
	assert.error(err, fnName + ": no callback error");
	assertionFn(actual, expected, fnName);
	})
	};
	}

	testCases.simple.forEach(makeAsserter(assert.equal));
	testCases.simpleLoose.forEach(makeAsserter(function(a, e, m){
	assert.ok(a == e, m);
	}));
	testCases.deep.forEach(makeAsserter(assert.deepEqual));

	client.testMapMap(42, function(err, response) {
	var expected: typeof response = {
	"4": {"1":1, "2":2, "3":3, "4":4},
	"-4": {"-4":-4, "-3":-3, "-2":-2, "-1":-1}
	};
	assert.error(err, 'testMapMap: no callback error');
	assert.deepEqual(expected, response, "testMapMap");
	});

	client.testStruct(testCases.out, function(err, response) {
	assert.error(err, "testStruct: no callback error");
	checkRecursively(testCases.out, response, "testStruct");
	});

	client.testNest(testCases.out2, function(err, response) {
	assert.error(err, "testNest: no callback error");
	checkRecursively(testCases.out2, response, "testNest");
	});

	client.testInsanity(testCases.crazy, function(err, response) {
	assert.error(err, "testInsanity: no callback error");
	checkRecursively(testCases.insanity, response, "testInsanity");
	});

	client.testException("TException", function(err, response) {
	assert.ok(err instanceof TException, 'testException: correct error type');
	assert.ok(!Boolean(response), 'testException: no response');
	});

	client.testException("Xception", function(err, response) {
	assert.ok(err instanceof ttypes.Xception, 'testException: correct error type');
	assert.ok(!Boolean(response), 'testException: no response');
	assert.equal(err.errorCode, 1001, 'testException: correct error code');
	assert.equal('Xception', err.message, 'testException: correct error message');
	});

	client.testException("no Exception", function(err, response) {
	assert.error(err, 'testException: no callback error');
	assert.ok(!Boolean(response), 'testException: no response');
	});

	client.testOneway(0, function(err, response) {
	assert.error(err, 'testOneway: no callback error');
	assert.strictEqual(response, undefined, 'testOneway: void response');
	});

	checkOffByOne(function(done) {
	client.testI32(-1, function(err, response) {
	assert.error(err, "checkOffByOne: no callback error");
	assert.equal(-1, response);
	assert.end();
	done();
	});
	}, callback);

	});
	};

	export function ThriftTestDriverPromise(client: ThriftTest.Client, callback: (status: string) => void) {

	test("Q Promise Client Tests", function(assert) {

	var checkRecursively = makeRecursiveCheck(assert);

	function fail(msg: string) {
	return function(error, response) {
	if (error !== null) {
	assert.fail(msg);
	}
	}
	}

	function makeAsserter(assertionFn: (a: any, b: any, msg?: string) => void) {
	return function(c: (string \| any)[]) {
	var fnName = c[0];
	var expected = c[1];
	(<any>client)[fnName](expected)
	.then(function(actual: any) {
	assertionFn(actual, expected, fnName);
	})
	.fail(fail("fnName"));
	};
	}

	testCases.simple.forEach(makeAsserter(assert.equal));
	testCases.simpleLoose.forEach(makeAsserter(function(a, e, m){
	assert.ok(a == e, m);
	}));
	testCases.deep.forEach(makeAsserter(assert.deepEqual));

	Q.resolve(client.testStruct(testCases.out))
	.then(function(response) {
	checkRecursively(testCases.out, response, "testStruct");
	})
	.fail(fail("testStruct"));

	Q.resolve(client.testNest(testCases.out2))
	.then(function(response) {
	checkRecursively(testCases.out2, response, "testNest");
	})
	.fail(fail("testNest"));

	Q.resolve(client.testInsanity(testCases.crazy))
	.then(function(response) {
	checkRecursively(testCases.insanity, response, "testInsanity");
	})
	.fail(fail("testInsanity"));

	Q.resolve(client.testException("TException"))
	.then(function(response) {
	fail("testException: TException");
	})
	.fail(function(err) {
	assert.ok(err instanceof TException);
	});

	Q.resolve(client.testException("Xception"))
	.then(function(response) {
	fail("testException: Xception");
	})
	.fail(function(err) {
	assert.ok(err instanceof ttypes.Xception);
	assert.equal(err.errorCode, 1001);
	assert.equal("Xception", err.message);
	});

	Q.resolve(client.testException("no Exception"))
	.then(function(response) {
	assert.equal(undefined, response); //void
	})
	.fail(fail("testException"));

	client.testOneway(0, fail("testOneway: should not answer"));

	checkOffByOne(function(done) {
	Q.resolve(client.testI32(-1))
	.then(function(response) {
	assert.equal(-1, response);
	assert.end();
	done();
	})
	.fail(fail("checkOffByOne"));
	}, callback);
	});
	};


	// Helper Functions
	// =========================================================

	function makeRecursiveCheck(assert: test.Test) {

	return function (map1: any, map2: any, msg: string) {
	var equal = true;

	var equal = checkRecursively(map1, map2);

	assert.ok(equal, msg);

	// deepEqual doesn't work with fields using node-int64
	function checkRecursively(map1: any, map2: any) : boolean {
	if (!(typeof map1 !== "function" && typeof map2 !== "function")) {
	return false;
	}
	if (!map1 \|\| typeof map1 !== "object") {
	//Handle int64 types (which use node-int64 in Node.js JavaScript)
	if ((typeof map1 === "number") && (typeof map2 === "object") &&
	(map2.buffer) && (map2.buffer instanceof Buffer) && (map2.buffer.length === 8)) {
	var n = new Int64(map2.buffer);
	return map1 === n.toNumber();
	} else {
	return map1 == map2;
	}
	} else {
	return Object.keys(map1).every(function(key) {
	return checkRecursively(map1[key], map2[key]);
	});
	}
	}
	}
	}

	function checkOffByOne(done: (callback: () => void) => void, callback: (message: string) => void) {

	var retry_limit = 30;
	var retry_interval = 100;
	var test_complete = false;
	var retrys = 0;

	/**
	* redo a simple test after the oneway to make sure we aren't "off by one" --
	* if the server treated oneway void like normal void, this next test will
	* fail since it will get the void confirmation rather than the correct
	* result. In this circumstance, the client will throw the exception:
	*
	* Because this is the last test against the server, when it completes
	* the entire suite is complete by definition (the tests run serially).
	*/
	done(function() {
	test_complete = true;
	});

	//We wait up to retry_limit * retry_interval for the test suite to complete
	function TestForCompletion() {
	if(test_complete && callback) {
	callback("Server successfully tested!");
	} else {
	if (++retrys < retry_limit) {
	setTimeout(TestForCompletion, retry_interval);
	} else if (callback) {
	callback("Server test failed to complete after " +
	(retry_limit * retry_interval / 1000) + " seconds");
	}
	}
	}

	setTimeout(TestForCompletion, retry_interval);
	}