@google-cloud/agones-sdk 1.18.0 → 1.25.0

package/package.json

@@ -4,13 +4,13 @@
         "url": "https://github.com/googleforgames/agones/issues"
     },
     "dependencies": {
-        "@grpc/grpc-js": "1.2.12",
-        "google-protobuf": "3.15.6"
+        "@grpc/grpc-js": "1.5.4",
+        "google-protobuf": "3.19.4"
     },
     "description": "Game Server SDK for Agones, the open source project for hosting dedicated game servers on Kubernetes",
     "devDependencies": {
-        "eslint": "^7.32.0",
-        "jasmine": "^3.9.0",
+        "eslint": "^8.8.0",
+        "jasmine": "^4.0.2",
         "nyc": "^15.1.0"
     },
     "homepage": "https://agones.dev",
@@ -26,5 +26,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "1.18.0"
+    "version": "1.25.0"
 }

package/spec/agonesSDK.spec.js

@@ -152,7 +152,7 @@ describe('AgonesSDK', () => {
 
 	describe('health', () => {
 		it('calls the server and passes calls to stream', async () => {
-			let stream = jasmine.createSpyObj('stream', ['write']);
+			let stream = jasmine.createSpyObj('stream', ['write', 'on']);
 			spyOn(agonesSDK.client, 'health').and.callFake(() => {
 				return stream;
 			});
@@ -163,7 +163,7 @@ describe('AgonesSDK', () => {
 		});
 
 		it('uses the same stream for subsequent calls', async () => {
-			let stream = jasmine.createSpyObj('stream', ['write']);
+			let stream = jasmine.createSpyObj('stream', ['write', 'on']);
 			spyOn(agonesSDK.client, 'health').and.callFake(() => {
 				return stream;
 			});
@@ -187,8 +187,55 @@ describe('AgonesSDK', () => {
 			}
 		});
 
+		it('calls the server and handles stream write error if callback provided', async () => {
+			let stream = jasmine.createSpyObj('stream', ['write', 'on']);
+			stream.write.and.callFake((chunk, encoding, callback) => {
+				callback('error');
+			});
+			spyOn(agonesSDK.client, 'health').and.callFake(() => {
+				return stream;
+			});
+			try {
+				agonesSDK.health((error) => {
+					expect(error).toEqual('error');
+				});
+			} catch (error) {
+				fail();
+			}
+		});
+
+		it('calls the server and re throws stream write error if no callback', async () => {
+			let stream = jasmine.createSpyObj('stream', ['write', 'on']);
+			stream.write.and.callFake((chunk, encoding, callback) => {
+				callback('error');
+			});
+			spyOn(agonesSDK.client, 'health').and.callFake(() => {
+				return stream;
+			});
+			try {
+				agonesSDK.health();
+				fail();
+			} catch (error) {
+				expect(agonesSDK.client.health).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+
+		it('does not call error callback if there was no stream error', async () => {
+			let stream = jasmine.createSpyObj('stream', ['write', 'on']);
+			stream.write.and.callFake((chunk, encoding, callback) => {
+				callback();
+			});
+			spyOn(agonesSDK.client, 'health').and.callFake(() => {
+				return stream;
+			});
+			agonesSDK.health(() => {
+				fail();
+			});
+		});
+
 		it('calls the server and handles stream completing', async () => {
-			let stream = jasmine.createSpyObj('stream', ['write']);
+			let stream = jasmine.createSpyObj('stream', ['write', 'on']);
 			spyOn(agonesSDK.client, 'health').and.callFake((callback) => {
 				let result = new messages.Empty();
 				callback(undefined, result);
@@ -249,35 +296,27 @@ describe('AgonesSDK', () => {
 			serverStream.emit('data', gameServer);
 
 			expect(callback).toHaveBeenCalled();
-			let result = callback.calls.argsFor(0)[0];
-			expect(result.status).toBeDefined();
-			expect(result.status.state).toEqual('up');
+			let callbackArgs = callback.calls.argsFor(0)[0];
+			expect(callbackArgs.status).toBeDefined();
+			expect(callbackArgs.status.state).toEqual('up');
 		});
-		it('captures CANCELLED errors only', async() => {
+		it('calls the server and passes errors to the optional error callback', async () => {
 			let serverStream = stream.Readable({read: () => undefined});
 			spyOn(agonesSDK.client, 'watchGameServer').and.callFake(() => {
 				return serverStream;
 			});
 
 			let callback = jasmine.createSpy('callback');
-			agonesSDK.watchGameServer(callback);
-
-			try {
-				serverStream.emit('error', {
-					code: grpc.status.CANCELLED
-				});
-			} catch (error) {
-				fail();
-			}
-
-			try {
-				serverStream.emit('error', {
-					code: grpc.status.ABORTED
-				});
-				fail();
-			} catch (error) {
-				expect(error.code).toEqual(grpc.status.ABORTED);
-			}
+			let errorCallback = jasmine.createSpy('errorCallback');
+			agonesSDK.watchGameServer(callback, errorCallback);
+
+			let error = {
+				code: grpc.status.CANCELLED
+			};
+			serverStream.emit('error', error);
+			expect(errorCallback).toHaveBeenCalled();
+			let errorCallbackArgs = errorCallback.calls.argsFor(0)[0];
+			expect(errorCallbackArgs).toEqual(error);
 		});
 	});
 
@@ -366,7 +405,7 @@ describe('AgonesSDK', () => {
 			expect(agonesSDK.client.close).toHaveBeenCalled();
 		});
 		it('ends the health stream if set', async () => {
-			let stream = jasmine.createSpyObj('stream', ['end', 'write']);
+			let stream = jasmine.createSpyObj('stream', ['end', 'write', 'on']);
 			spyOn(agonesSDK.client, 'health').and.callFake(() => {
 				return stream;
 			});

package/src/agonesSDK.js

@@ -93,14 +93,25 @@ class AgonesSDK {
 		});
 	}
 
-	health() {
+	health(errorCallback) {
 		if (this.healthStream === undefined) {
 			this.healthStream = this.client.health(() => {
 				// Ignore error as this can't be caught
 			});
+			this.healthStream.on('error', () => {
+				// ignore error, prevent from being uncaught
+			});
 		}
 		const request = new messages.Empty();
-		this.healthStream.write(request);
+		this.healthStream.write(request, null, (error) => {
+			if (error) {
+				if (errorCallback) {
+					errorCallback(error);
+					return;
+				}
+				throw error;
+			}
+		});
 	}
 
 	async getGameServer() {
@@ -116,19 +127,17 @@ class AgonesSDK {
 		});
 	}
 
-	watchGameServer(callback) {
+	watchGameServer(callback, errorCallback) {
 		const request = new messages.Empty();
 		const stream = this.client.watchGameServer(request);
 		stream.on('data', (data) => {
 			callback(data.toObject());
 		});
-		stream.on('error', (error) => {
-			if (error.code === grpc.status.CANCELLED) {
-				// Capture error when call is cancelled
-				return;
-			}
-			throw error;
-		});
+		if (errorCallback) {
+			stream.on('error', (error) => {
+				errorCallback(error);
+			});
+		}
 		this.streams.push(stream);
 	}