@google-cloud/agones-sdk 1.40.0 → 1.41.0-dev

package/package.json

@@ -4,13 +4,13 @@
         "url": "https://github.com/googleforgames/agones/issues"
     },
     "dependencies": {
-        "@grpc/grpc-js": "1.7.3",
+        "@grpc/grpc-js": "1.10.7",
         "google-protobuf": "3.21.2"
     },
     "description": "Game Server SDK for Agones, the open source project for hosting dedicated game servers on Kubernetes",
     "devDependencies": {
-        "eslint": "^8.27.0",
-        "jasmine": "^4.5.0",
+        "eslint": "^8.57.0",
+        "jasmine": "^5.1.0",
         "nyc": "^15.1.0"
     },
     "homepage": "https://agones.dev",
@@ -26,5 +26,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "1.40.0"
+    "version": "1.41.0-dev"
 }

package/spec/betaAgonesSDK.spec.js

@@ -0,0 +1,419 @@
+// Copyright 2020 Google LLC All Rights Reserved.
+//
+// Licensed 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.
+
+const grpc = require('@grpc/grpc-js');
+
+const messages = require('../lib/beta/beta_pb');
+const Beta = require('../src/beta');
+
+describe('Beta', () => {
+	let beta;
+
+	beforeEach(() => {
+		const address = 'localhost:9357';
+		const credentials = grpc.credentials.createInsecure();
+		beta = new Beta(address, credentials);
+	});
+
+	describe('getCounterCount', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'getCounter').and.callFake((request, callback) => {
+				let counter = new messages.Counter();
+				counter.setCount(10);
+				callback(undefined, counter);
+			});
+
+			let count = await beta.getCounterCount('key');
+			expect(beta.client.getCounter).toHaveBeenCalled();
+			expect(count).toEqual(10);
+			let request = beta.client.getCounter.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'getCounter').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.getCounterCount('key');
+				fail();
+			} catch (error) {
+				expect(beta.client.getCounter).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('incrementCounter', () => {
+		it('calls the server and handles the response while under capacity', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				let counter = new messages.Counter();
+				callback(undefined, counter);
+			});
+
+			let response = await beta.incrementCounter('key', 5);
+			expect(beta.client.updateCounter).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.updateCounter.calls.argsFor(0)[0];
+			expect(request.getCounterupdaterequest().getName()).toEqual('key');
+			expect(request.getCounterupdaterequest().getCountdiff()).toEqual(5);
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.incrementCounter('key', 5);
+				fail();
+			} catch (error) {
+				expect(beta.client.updateCounter).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('decrementCounter', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				let counter = new messages.Counter();
+				callback(undefined, counter);
+			});
+
+			let response = await beta.decrementCounter('key', 5);
+			expect(beta.client.updateCounter).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.updateCounter.calls.argsFor(0)[0];
+			expect(request.getCounterupdaterequest().getName()).toEqual('key');
+			expect(request.getCounterupdaterequest().getCountdiff()).toEqual(-5);
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.decrementCounter('key', 5);
+				fail();
+			} catch (error) {
+				expect(beta.client.updateCounter).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('setCounterCount', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				let counter = new messages.Counter();
+				callback(undefined, counter);
+			});
+
+			let response = await beta.setCounterCount('key', 5);
+			expect(beta.client.updateCounter).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.updateCounter.calls.argsFor(0)[0];
+			expect(request.getCounterupdaterequest().getName()).toEqual('key');
+			expect(request.getCounterupdaterequest().getCount().getValue()).toEqual(5);
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.setCounterCount('key', 5);
+				fail();
+			} catch (error) {
+				expect(beta.client.updateCounter).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('getCounterCapacity', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'getCounter').and.callFake((request, callback) => {
+				let counter = new messages.Counter();
+				counter.setCapacity(10);
+				callback(undefined, counter);
+			});
+
+			let capacity = await beta.getCounterCapacity('key');
+			expect(beta.client.getCounter).toHaveBeenCalled();
+			expect(capacity).toEqual(10);
+			let request = beta.client.getCounter.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'getCounter').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.getCounterCapacity('key');
+				fail();
+			} catch (error) {
+				expect(beta.client.getCounter).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('setCounterCapacity', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				let counter = new messages.Counter();
+				callback(undefined, counter);
+			});
+
+			let response = await beta.setCounterCapacity('key', 5);
+			expect(beta.client.updateCounter).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.updateCounter.calls.argsFor(0)[0];
+			expect(request.getCounterupdaterequest().getName()).toEqual('key');
+			expect(request.getCounterupdaterequest().getCapacity().getValue()).toEqual(5);
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'updateCounter').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.setCounterCapacity('key', 5);
+				fail();
+			} catch (error) {
+				expect(beta.client.updateCounter).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('getListCapacity', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				let list = new messages.List();
+				list.setCapacity(10);
+				callback(undefined, list);
+			});
+
+			let capacity = await beta.getListCapacity('key');
+			expect(beta.client.getList).toHaveBeenCalled();
+			expect(capacity).toEqual(10);
+			let request = beta.client.getList.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.getListCapacity('key');
+				fail();
+			} catch (error) {
+				expect(beta.client.getList).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('setListCapacity', () => {
+		it('calls the server and handles the response while in range', async () => {
+			spyOn(beta.client, 'updateList').and.callFake((request, callback) => {
+				let list = new messages.List();
+				callback(undefined, list);
+			});
+
+			let response = await beta.setListCapacity('key', 5);
+			expect(beta.client.updateList).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.updateList.calls.argsFor(0)[0];
+			expect(request.getList().getName()).toEqual('key');
+			expect(request.getList().getCapacity()).toEqual(5);
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'updateList').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.setListCapacity('key', 5);
+				fail();
+			} catch (error) {
+				expect(beta.client.updateList).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('listContains', () => {
+		it('calls the server and handles the response when the value is contained', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				let list = new messages.List();
+				list.setValuesList(['firstValue', 'secondValue']);
+				callback(undefined, list);
+			});
+
+			let contains = await beta.listContains('key', 'secondValue');
+			expect(beta.client.getList).toHaveBeenCalled();
+			expect(contains).toEqual(true);
+			let request = beta.client.getList.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles the response when the value is not contained', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				let list = new messages.List();
+				list.setValuesList(['firstValue', 'secondValue']);
+				callback(undefined, list);
+			});
+
+			let contains = await beta.listContains('key', 'thirdValue');
+			expect(beta.client.getList).toHaveBeenCalled();
+			expect(contains).toEqual(false);
+			let request = beta.client.getList.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.listContains('key', 'value');
+				fail();
+			} catch (error) {
+				expect(beta.client.getList).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('getListLength', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				let list = new messages.List();
+				list.setValuesList(['firstValue', 'secondValue']);
+				callback(undefined, list);
+			});
+
+			let length = await beta.getListLength('key');
+			expect(beta.client.getList).toHaveBeenCalled();
+			expect(length).toEqual(2);
+			let request = beta.client.getList.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.getListLength('key');
+				fail();
+			} catch (error) {
+				expect(beta.client.getList).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('getListValues', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				let list = new messages.List();
+				list.setValuesList(['firstValue', 'secondValue']);
+				callback(undefined, list);
+			});
+
+			let values = await beta.getListValues('key');
+			expect(beta.client.getList).toHaveBeenCalled();
+			expect(values).toEqual(['firstValue', 'secondValue']);
+			let request = beta.client.getList.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'getList').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.getListValues('key');
+				fail();
+			} catch (error) {
+				expect(beta.client.getList).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('appendListValue', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'addListValue').and.callFake((request, callback) => {
+				let list = new messages.List();
+				callback(undefined, list);
+			});
+
+			let response = await beta.appendListValue('key', 'value');
+			expect(beta.client.addListValue).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.addListValue.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+			expect(request.getValue()).toEqual('value');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'addListValue').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.appendListValue('key', 'value');
+				fail();
+			} catch (error) {
+				expect(beta.client.addListValue).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+
+	describe('deleteListValue', () => {
+		it('calls the server and handles the response', async () => {
+			spyOn(beta.client, 'removeListValue').and.callFake((request, callback) => {
+				let list = new messages.List();
+				callback(undefined, list);
+			});
+
+			let response = await beta.deleteListValue('key', 'value');
+			expect(beta.client.removeListValue).toHaveBeenCalled();
+			expect(response).toEqual(undefined);
+			let request = beta.client.removeListValue.calls.argsFor(0)[0];
+			expect(request.getName()).toEqual('key');
+			expect(request.getValue()).toEqual('value');
+		});
+
+		it('calls the server and handles failure', async () => {
+			spyOn(beta.client, 'removeListValue').and.callFake((request, callback) => {
+				callback('error', undefined);
+			});
+			try {
+				await beta.deleteListValue('key', 'value');
+				fail();
+			} catch (error) {
+				expect(beta.client.removeListValue).toHaveBeenCalled();
+				expect(error).toEqual('error');
+			}
+		});
+	});
+});

package/src/agonesSDK.js

@@ -15,6 +15,7 @@
 const grpc = require('@grpc/grpc-js');
 
 const Alpha = require('./alpha');
+const Beta = require('./beta');
 
 const messages = require('../lib/sdk_pb');
 const servicesPackageDefinition = require('../lib/sdk_grpc_pb');
@@ -28,6 +29,7 @@ class AgonesSDK {
 		this.healthStream = undefined;
 		this.streams = [];
 		this.alpha = new Alpha(address, credentials);
+		this.beta = new Beta(address, credentials);
 	}
 
 	get port() {

package/src/alpha.js

@@ -83,7 +83,7 @@ class Alpha {
 		});
 	}
 
-	getPlayerCount() {
+	async getPlayerCount() {
 		const request = new messages.Empty();
 
 		return new Promise((resolve, reject) => {
@@ -97,7 +97,7 @@ class Alpha {
 		});
 	}
 
-	isPlayerConnected(playerID) {
+	async isPlayerConnected(playerID) {
 		const request = new messages.PlayerID();
 		request.setPlayerid(playerID);
 
@@ -112,7 +112,7 @@ class Alpha {
 		});
 	}
 
-	getConnectedPlayers() {
+	async getConnectedPlayers() {
 		const request = new messages.Empty();
 
 		return new Promise((resolve, reject) => {

package/src/beta.d.ts

@@ -0,0 +1,43 @@
+// Copyright 2023 Google LLC All Rights Reserved.
+//
+// Licensed 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.
+
+declare class Beta {
+	getCounterCount(key: string): Promise<number>
+
+	incrementCounter(key: string, amount: number): Promise<void>
+
+	decrementCounter(key: string, amount: number): Promise<void>
+
+	setCounterCount(key: string, amount: number): Promise<void>
+
+	getCounterCapacity(key: string): Promise<number>
+
+	setCounterCapacity(key: string, amount: number): Promise<void>
+
+	getListCapacity(key: string): Promise<number>
+
+	setListCapacity(key: string, amount: number): Promise<void>
+
+	listContains(key: string, value: string): Promise<boolean>
+
+	getListLength(key: string): Promise<number>
+
+	getListValues(key: string): Promise<string[]>
+
+	appendListValue(key: string, value: string): Promise<void>
+
+	deleteListValue(key:string , value: string): Promise<void>
+}
+
+export default Beta;