merge with upstream https://github.com/RblSb/SyncTubeHEADmaster

2 files changed, 213 insertions, 0 deletions

diff --git a/test/tests/TestServer.hx b/test/tests/TestServer.hx
index 2d0b71d..2bd4a3a 100644
--- a/test/tests/TestServer.hx
+++ b/test/tests/TestServer.hx
@@ -1,5 +1,6 @@
 package test.tests;
 
+import Types.ProgressType;
 import Types.WsEvent;
 import Types.WsEventType;
 import haxe.Json;
@@ -19,6 +20,7 @@ class TestServer extends Test {
 	@:timeout(500)
 	function testBadRequests(async:Async) {
 		final server = new Main({loadState: false});
+		server.config.gatePassword = "";
 		server.onServerInited = () -> {
 			final url = 'http://${server.localIp}:${server.port}';
 			request('$url/你好，世界!@$^&*)_+-=', data -> {
@@ -52,6 +54,66 @@ class TestServer extends Test {
 		return ~/\r?\n/g.split(text);
 	}
 
+	@:timeout(2000)
+	function testIncompleteUpload(async:Async) {
+		final server = new Main({loadState: false});
+		server.onServerInited = () -> {
+			final client = new FakeClient(server.localIp, server.port);
+			final url = "/cache/upload-test.mp4";
+			client.message().then(data -> {
+				Assert.equals(Connected, data.type);
+				client.name = data.connected.clientName;
+				return client.send({
+					type: AddVideo,
+					addVideo: {
+						item: {
+							url: url,
+							title: "upload",
+							author: "",
+							duration: 30,
+							isTemp: false,
+							playerType: RawType,
+							doCache: false,
+							isIncomplete: true
+						},
+						atEnd: true
+					}
+				});
+			}).then(data -> {
+				Assert.equals(AddVideo, data.type);
+				Assert.isTrue(data.addVideo.item.isIncomplete == true);
+				Assert.equals(1, server.videoList.length);
+				// uploads stream while incomplete, so they stay playable
+				Assert.isTrue(server.videoList.getItem(0).isPlayable());
+				return client.send({
+					type: Progress,
+					progress: {
+						type: Uploading,
+						ratio: 0.5,
+						url: url
+					}
+				});
+			}).then(data -> {
+				Assert.equals(Progress, data.type);
+				Assert.equals(ProgressType.Uploading, data.progress.type);
+				Assert.equals(0.5, data.progress.ratio);
+				return client.send({
+					type: Progress,
+					progress: {
+						type: Completed,
+						ratio: 1,
+						url: url
+					}
+				});
+			}).then(data -> {
+				Assert.equals(Progress, data.type);
+				Assert.equals(ProgressType.Completed, data.progress.type);
+				Assert.isFalse(server.videoList.getItem(0).isIncomplete == true);
+				async.done();
+			});
+		}
+	}
+
 	function request(url:String, onComplete:(data:String) -> Void):Void {
 		Http.get(url, r -> {
 			r.setEncoding("utf8");
diff --git a/test/tests/TestSkipVote.hx b/test/tests/TestSkipVote.hx
new file mode 100644
index 0000000..d4e9c8d
--- /dev/null
+++ b/test/tests/TestSkipVote.hx
@@ -0,0 +1,151 @@
+package test.tests;
+
+import Types.Permission;
+import Types.ServerConfig;
+import Types.WsEvent;
+import Types.WsEventType;
+import haxe.Json;
+import server.Main;
+import server.VideoTimer;
+import utest.Assert;
+import utest.Test;
+
+@:access(server.Main)
+class TestSkipVote extends Test {
+	var server:Main;
+	var events:Array<WsEvent>;
+
+	function setup():Void {
+		// Keep voting tests independent of HTTP ports, files and playback timers.
+		server = Type.createEmptyInstance(Main);
+		events = [];
+		final permissions:Array<Permission> = [RemoveVideoPerm];
+		final config:ServerConfig = cast {
+			permissions: {
+				banned: [], guest: permissions, user: permissions,
+				leader: permissions, admin: permissions
+			}
+		};
+		Reflect.setField(server, "config", config);
+		Reflect.setField(server, "clients", []);
+		Reflect.setField(server, "skipVotes", new Map<Int, Bool>());
+		Reflect.setField(server, "videoTimer", new VideoTimer());
+		final list = new VideoList();
+		list.addItem({
+			url: "video", title: "Video", author: "Queuer", duration: 60,
+			isTemp: true, doCache: false, playerType: RawType
+		}, true);
+		Reflect.setField(server, "videoList", list);
+	}
+
+	function addClient(name:String, id:Int):Client {
+		final ws:Dynamic = {
+			send: (text:String, options:Dynamic) -> events.push(Json.parse(text))
+		};
+		final client = new Client(cast ws, null, id, name, 0);
+		server.clients.push(client);
+		return client;
+	}
+
+	function vote(client:Client, url = "video"):Void {
+		server.handleSkipVote(client, {type: SkipVideo, skipVideo: {url: url}});
+	}
+
+	function testGiveupCommand():Void {
+		final parsed = client.Commands.parse("/giveup Guest 2");
+		Assert.equals(client.Commands.CommandId.Giveup, parsed.cmd.name);
+		Assert.equals(1, client.Commands.filterForAutocomplete("/give").length);
+	}
+
+	function testStrictMajorityWithLiveStats():Void {
+		final first = addClient("First", 0);
+		final second = addClient("Second", 1);
+		final third = addClient("Third", 2);
+		addClient("Fourth", 3);
+		vote(first);
+		Assert.equals(1, events[0].skipVideoStats.voted);
+		Assert.equals(4, events[0].skipVideoStats.total);
+		Assert.equals(3, events[0].skipVideoStats.required);
+		vote(second);
+		Assert.equals(1, server.videoList.length);
+		vote(third);
+		Assert.equals(0, server.videoList.length);
+		Assert.equals(SkipVideo, events[events.length - 1].type);
+		Assert.isNull(server.activeSkipVoteUrl);
+	}
+
+	function testDuplicateAndStaleVotes():Void {
+		final first = addClient("First", 0);
+		addClient("Second", 1);
+		vote(first);
+		vote(first);
+		vote(first, "previous-video");
+		server.skipVideo({type: SkipVideo, skipVideo: {url: "previous-video"}});
+		Assert.equals(1, server.getSkipVoteCount());
+		Assert.equals("video", server.activeSkipVoteUrl);
+		Assert.equals(1, server.videoList.length);
+	}
+
+	function testAdminOverride():Void {
+		final admin = addClient("Admin", 0);
+		admin.isAdmin = true;
+		addClient("Second", 1);
+		addClient("Third", 2);
+		vote(admin);
+		Assert.equals(0, server.videoList.length);
+	}
+
+	function testQueuerOverrideDuringVote():Void {
+		final first = addClient("First", 0);
+		final queuer = addClient("Queuer", 1);
+		addClient("Third", 2);
+		vote(first);
+		vote(queuer);
+		Assert.equals(0, server.videoList.length);
+		Assert.equals(0, server.getSkipVoteCount());
+	}
+
+	function testBannedClientsExcluded():Void {
+		final first = addClient("First", 0);
+		addClient("Second", 1);
+		addClient("Banned", 2).isBanned = true;
+		vote(first);
+		Assert.equals(2, events[0].skipVideoStats.total);
+		Assert.equals(2, events[0].skipVideoStats.required);
+	}
+
+	function testDisconnectCanCompleteMajority():Void {
+		final first = addClient("First", 0);
+		final second = addClient("Second", 1);
+		addClient("Third", 2);
+		final departing = addClient("Fourth", 3);
+		vote(first);
+		vote(second);
+		server.clients.remove(departing);
+		server.skipVotes.remove(departing.id);
+		server.updateSkipVote();
+		Assert.equals(0, server.videoList.length);
+	}
+
+	function testDepartingVoterAndReusedId():Void {
+		final first = addClient("First", 0);
+		addClient("Second", 1);
+		addClient("Third", 2);
+		vote(first);
+		server.clients.remove(first);
+		server.skipVotes.remove(first.id);
+		server.updateSkipVote();
+		addClient("Replacement", 0);
+		Assert.equals(0, server.getSkipVoteCount());
+		Assert.equals(1, server.videoList.length);
+	}
+
+	function testRenamingDoesNotDuplicateVote():Void {
+		final first = addClient("First", 0);
+		addClient("Second", 1);
+		vote(first);
+		first.name = "Renamed";
+		vote(first);
+		Assert.equals(1, server.getSkipVoteCount());
+	}
+}