Add chrome.cast.media class tests

test/spec/shim/media/EditTracksInfoRequest.spec.js

@@ -0,0 +1,28 @@
+"use strict";
+
+describe("chrome.cast.media.EditTracksInfoRequest", () => {
+    it("should have all properties", async () => {
+        const editTracksInfoRequest = new chrome.cast.media.EditTracksInfoRequest();
+
+        expect(editTracksInfoRequest.activeTrackIds).toBe(null);
+        expect(editTracksInfoRequest.requestId).toBe(0);
+        expect(editTracksInfoRequest.textTrackStyle).toBe(null);
+    });
+
+    it("should have expected assigned properties", async () => {
+        const textTrackStyle = new chrome.cast.media.TextTrackStyle();
+        textTrackStyle.backgroundColor = "#fefefeff";
+        textTrackStyle.fontFamily = "__fontFamily";
+        textTrackStyle.windowRoundedCornerRadius = 5;
+
+        const editTracksInfoRequest = new chrome.cast.media.EditTracksInfoRequest(
+                [ 5, 8, 12 ], textTrackStyle);
+
+        expect(editTracksInfoRequest.activeTrackIds).toEqual([ 5, 8, 12 ]);
+        expect(editTracksInfoRequest.textTrackStyle).toEqual(jasmine.objectContaining({
+            backgroundColor: "#fefefeff"
+          , fontFamily: "__fontFamily"
+          , windowRoundedCornerRadius: 5
+        }));
+    });
+});

test/spec/shim/media/GenericMediaMetadata.spec.js

@@ -0,0 +1,15 @@
+"use strict";
+
+describe("chrome.cast.media.GenericMediaMetadata", () => {
+    it("should have all properties", async () => {
+        const genericMediaMetadata = new chrome.cast.media.GenericMediaMetadata();
+
+        expect(genericMediaMetadata.images).toBe(null);
+        expect(genericMediaMetadata.metadataType).toBe(0);
+        expect(genericMediaMetadata.releaseDate).toBe(null);
+        expect(genericMediaMetadata.releaseYear).toBe(null);
+        expect(genericMediaMetadata.subtitle).toBe(null);
+        expect(genericMediaMetadata.title).toBe(null);
+        expect(genericMediaMetadata.type).toBe(0);
+    });
+});

test/spec/shim/media/GetStatusRequest.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+
+describe("chrome.cast.media.GetStatusRequest", () => {
+    it("should have all properties", async () => {
+        const getStatusRequest = new chrome.cast.media.GetStatusRequest();
+
+        expect(getStatusRequest.customData).toBe(null);
+    });
+});

test/spec/shim/media/LoadRequest.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+
+describe("chrome.cast.media.LoadRequest", () => {
+    it("should have all properties", async () => {
+        const loadRequest = new chrome.cast.media.LoadRequest();
+
+        expect(loadRequest.activeTrackIds).toBe(null);
+        expect(loadRequest.autoplay).toBe(true);
+        expect(loadRequest.currentTime).toBe(null);
+        expect(loadRequest.customData).toBe(null);
+        expect(loadRequest.media).toBe(undefined);
+        expect(loadRequest.requestId).toBe(0);
+        expect(loadRequest.sessionId).toBe(null);
+        expect(loadRequest.type).toBe("LOAD");
+    });
+
+    it("should have expected assigned properties", async () => {
+        const mediaInfo = new chrome.cast.media.MediaInfo(
+                "__contentId", "video/mp4");
+        const loadRequest = new chrome.cast.media.LoadRequest(mediaInfo);
+
+        expect(loadRequest.media).toEqual(jasmine.objectContaining({
+            contentId: "__contentId"
+          , contentType: "video/mp4"
+        }));
+    });
+});

test/spec/shim/media/Media.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+
+describe("chrome.cast.media.Media", () => {
+    it("should have all properties", async () => {
+        const media = new chrome.cast.media.Media();
+
+        expect(media.activeTrackIds).toBe(null);
+        expect(media.currentItemId).toBe(null);
+        expect(media.customData).toBe(null);
+        expect(media.idleReason).toBe(null);
+        expect(media.items).toBe(null);
+        expect(media.loadingItemId).toBe(null);
+        expect(media.media).toBe(null);
+        expect(media.mediaSessionId).toBe(undefined);
+        expect(media.playbackRate).toBe(1);
+        expect(media.playerState).toBe("IDLE");
+        expect(media.preloadedItemId).toBe(null);
+        expect(media.repeatMode).toBe("REPEAT_OFF");
+        expect(media.sessionId).toBe(undefined);
+        expect(media.supportedMediaCommands).toEqual([]);
+        expect(media.volume).toEqual(jasmine.objectContaining({
+            level: null
+          , muted: null
+        }));
+    });
+
+    it("should have expected assigned properties", async () => {
+        const media = new chrome.cast.media.Media("__sessionId", 5);
+
+        expect(media.mediaSessionId).toBe(5);
+        expect(media.sessionId).toBe("__sessionId");
+    });
+});

test/spec/shim/media/MediaInfo.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+
+describe("chrome.cast.media.MediaInfo", () => {
+    it("should have all properties", async () => {
+        const mediaInfo = new chrome.cast.media.MediaInfo();
+
+        expect(mediaInfo.contentId).toBe(undefined);
+        expect(mediaInfo.contentType).toBe(undefined);
+        expect(mediaInfo.customData).toBe(null);
+        expect(mediaInfo.duration).toBe(null);
+        expect(mediaInfo.metadata).toBe(null);
+        expect(mediaInfo.streamType).toBe("BUFFERED");
+        expect(mediaInfo.textTrackStyle).toBe(null);
+        expect(mediaInfo.tracks).toBe(null);
+    });
+
+    it("should have expected assigned properties", async () => {
+        const mediaInfo = new chrome.cast.media.MediaInfo("__contentId", "video/mp4");
+
+        expect(mediaInfo.contentId).toBe("__contentId");
+        expect(mediaInfo.contentType).toBe("video/mp4");
+    });
+});

test/spec/shim/media/MovieMediaMetadata.spec.js

@@ -0,0 +1,16 @@
+"use strict";
+
+describe("chrome.cast.media.MovieMediaMetadata", () => {
+    it("should have all properties", async () => {
+        const movieMediaMetadata = new chrome.cast.media.MovieMediaMetadata();
+
+        expect(movieMediaMetadata.images).toBe(null);
+        expect(movieMediaMetadata.metadataType).toBe(1);
+        expect(movieMediaMetadata.releaseDate).toBe(null);
+        expect(movieMediaMetadata.releaseYear).toBe(null);
+        expect(movieMediaMetadata.studio).toBe(null);
+        expect(movieMediaMetadata.subtitle).toBe(null);
+        expect(movieMediaMetadata.title).toBe(null);
+        expect(movieMediaMetadata.type).toBe(1);
+    });
+});

test/spec/shim/media/MusicTrackMediaMetadata.spec.js

@@ -0,0 +1,22 @@
+"use strict";
+
+describe("chrome.cast.media.MusicTrackMediaMetadata", () => {
+    it("should have all properties", async () => {
+        const musicTrackMediaMetadata = new chrome.cast.media.MusicTrackMediaMetadata();
+
+        expect(musicTrackMediaMetadata.albumArtist).toBe(null);
+        expect(musicTrackMediaMetadata.albumName).toBe(null);
+        expect(musicTrackMediaMetadata.artist).toBe(null);
+        expect(musicTrackMediaMetadata.artistName).toBe(null);
+        expect(musicTrackMediaMetadata.composer).toBe(null);
+        expect(musicTrackMediaMetadata.discNumber).toBe(null);
+        expect(musicTrackMediaMetadata.images).toBe(null);
+        expect(musicTrackMediaMetadata.metadataType).toBe(3);
+        expect(musicTrackMediaMetadata.releaseDate).toBe(null);
+        expect(musicTrackMediaMetadata.releaseYear).toBe(null);
+        expect(musicTrackMediaMetadata.songName).toBe(null);
+        expect(musicTrackMediaMetadata.title).toBe(null);
+        expect(musicTrackMediaMetadata.trackNumber).toBe(null);
+        expect(musicTrackMediaMetadata.type).toBe(3);
+    });
+});

test/spec/shim/media/PauseRequest.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+
+describe("chrome.cast.media.PauseRequest", () => {
+    it("should have all properties", async () => {
+        const pauseRequest = new chrome.cast.media.PauseRequest();
+
+        expect(pauseRequest.customData).toBe(null);
+    });
+});

test/spec/shim/media/PhotoMediaMetadata.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+
+describe("chrome.cast.media.PhotoMediaMetadata", () => {
+    it("should have all properties", async () => {
+        const photoMediaMetadata = new chrome.cast.media.PhotoMediaMetadata();
+
+        expect(photoMediaMetadata.artist).toBe(null);
+        expect(photoMediaMetadata.creationDateTime).toBe(null);
+        expect(photoMediaMetadata.height).toBe(null);
+        expect(photoMediaMetadata.images).toBe(null);
+        expect(photoMediaMetadata.latitude).toBe(null);
+        expect(photoMediaMetadata.location).toBe(null);
+        expect(photoMediaMetadata.longitude).toBe(null);
+        expect(photoMediaMetadata.metadataType).toBe(4);
+        expect(photoMediaMetadata.title).toBe(null);
+        expect(photoMediaMetadata.type).toBe(4);
+        expect(photoMediaMetadata.width).toBe(null);
+    });
+});

test/spec/shim/media/PlayRequest.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+
+describe("chrome.cast.media.PlayRequest", () => {
+    it("should have all properties", async () => {
+        const playRequest = new chrome.cast.media.PlayRequest();
+
+        expect(playRequest.customData).toBe(null);
+    });
+});

test/spec/shim/media/QueueInsertItemsRequest.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+
+describe("chrome.cast.media.QueueInsertItemsRequest", () => {
+    it("should have all properties", async () => {
+        const queueInsertItemsRequest = new chrome.cast.media.QueueInsertItemsRequest();
+
+        expect(queueInsertItemsRequest.customData).toBe(null);
+        expect(queueInsertItemsRequest.insertBefore).toBe(null);
+        expect(queueInsertItemsRequest.items).toBe(undefined);
+        expect(queueInsertItemsRequest.requestId).toBe(null);
+        expect(queueInsertItemsRequest.sessionId).toBe(null);
+        expect(queueInsertItemsRequest.type).toBe("QUEUE_INSERT");
+    });
+
+    it("should have expected assigned properties", async () => {
+        const media1 = new chrome.cast.media.MediaInfo("media1", "video/mp4");
+        const media2 = new chrome.cast.media.MediaInfo("media2", "audio/mp3");
+
+        const queueInsertItemsRequest = new chrome.cast.media.QueueInsertItemsRequest([
+            new chrome.cast.media.QueueItem(media1)
+          , new chrome.cast.media.QueueItem(media2)
+        ]);
+
+        expect(queueInsertItemsRequest.items).toEqual([
+            jasmine.objectContaining({ media: jasmine.objectContaining({
+                contentId: "media1"
+              , contentType: "video/mp4"
+            })})
+          , jasmine.objectContaining({ media: jasmine.objectContaining({
+                contentId: "media2"
+              , contentType: "audio/mp3"
+            })})
+        ]);
+    });
+});

test/spec/shim/media/QueueItem.spec.js

@@ -0,0 +1,26 @@
+"use strict";
+
+describe("chrome.cast.media.QueueItem", () => {
+    it("should have all properties", async () => {
+        const queueItem = new chrome.cast.media.QueueItem();
+
+        expect(queueItem.activeTrackIds).toBe(null);
+        expect(queueItem.autoplay).toBe(true);
+        expect(queueItem.customData).toBe(null);
+        expect(queueItem.itemId).toBe(null);
+        expect(queueItem.media).toBe(undefined);
+        expect(queueItem.playbackDuration).toBe(null);
+        expect(queueItem.preloadTime).toBe(0);
+        expect(queueItem.startTime).toBe(0);
+    });
+
+    it("should have expected assigned properties", async () => {
+        const media = new chrome.cast.media.MediaInfo("__contentId", "video/mp4");
+        const queueItem = new chrome.cast.media.QueueItem(media);
+
+        expect(queueItem.media).toEqual(jasmine.objectContaining({
+            contentId: "__contentId"
+          , contentType: "video/mp4"
+        }));
+    });
+});

test/spec/shim/media/QueueLoadRequest.spec.js

@@ -0,0 +1,36 @@
+"use strict";
+
+describe("chrome.cast.media.QueueLoadRequest", () => {
+    it("should have all properties", async () => {
+        const queueLoadRequest = new chrome.cast.media.QueueLoadRequest();
+
+        expect(queueLoadRequest.customData).toBe(null);
+        expect(queueLoadRequest.items).toBe(undefined);
+        expect(queueLoadRequest.repeatMode).toBe("REPEAT_OFF");
+        expect(queueLoadRequest.requestId).toBe(null);
+        expect(queueLoadRequest.sessionId).toBe(null);
+        expect(queueLoadRequest.startIndex).toBe(0);
+        expect(queueLoadRequest.type).toBe("QUEUE_LOAD");
+    });
+
+    it("should have expected assigned properties", async () => {
+        const media1 = new chrome.cast.media.MediaInfo("media1", "video/mp4");
+        const media2 = new chrome.cast.media.MediaInfo("media2", "audio/mp3");
+
+        const queueLoadRequest = new chrome.cast.media.QueueLoadRequest([
+            new chrome.cast.media.QueueItem(media1)
+          , new chrome.cast.media.QueueItem(media2)
+        ]);
+
+        expect(queueLoadRequest.items).toEqual([
+            jasmine.objectContaining({ media: jasmine.objectContaining({
+                contentId: "media1"
+              , contentType: "video/mp4"
+            })})
+          , jasmine.objectContaining({ media: jasmine.objectContaining({
+                contentId: "media2"
+              , contentType: "audio/mp3"
+            })})
+        ]);
+    });
+});

test/spec/shim/media/QueueRemoveItemsRequest.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+
+describe("chrome.cast.media.QueueRemoveItemsRequest", () => {
+    it("should have all properties", async () => {
+        const queueRemoveItemsRequest = new chrome.cast.media.QueueRemoveItemsRequest();
+
+        expect(queueRemoveItemsRequest.customData).toBe(null);
+        expect(queueRemoveItemsRequest.itemIds).toBe(undefined);
+        expect(queueRemoveItemsRequest.requestId).toBe(null);
+        expect(queueRemoveItemsRequest.sessionId).toBe(null);
+        expect(queueRemoveItemsRequest.type).toBe("QUEUE_REMOVE");
+    });
+
+    it("should have expected assigned properties", async () => {
+        const queueRemoveItemsRequest = new chrome.cast.media.QueueRemoveItemsRequest(
+                [ 5, 8, 12 ]);
+
+        expect(queueRemoveItemsRequest.itemIds).toEqual([ 5, 8, 12 ]);
+    });
+});

test/spec/shim/media/QueueReorderItemsRequest.spec.js

@@ -0,0 +1,21 @@
+"use strict";
+
+describe("chrome.cast.media.QueueReorderItemsRequest", () => {
+    it("should have all properties", async () => {
+        const queueReorderItemsRequest = new chrome.cast.media.QueueReorderItemsRequest();
+
+        expect(queueReorderItemsRequest.customData).toBe(null);
+        expect(queueReorderItemsRequest.insertBefore).toBe(null);
+        expect(queueReorderItemsRequest.itemIds).toBe(undefined);
+        expect(queueReorderItemsRequest.requestId).toBe(null);
+        expect(queueReorderItemsRequest.sessionId).toBe(null);
+        expect(queueReorderItemsRequest.type).toBe("QUEUE_REORDER");
+    });
+
+    it("should have expected assigned properties", async () => {
+        const queueReorderItemsRequest = new chrome.cast.media.QueueReorderItemsRequest(
+                [ 5, 8, 12 ]);
+
+        expect(queueReorderItemsRequest.itemIds).toEqual([ 5, 8, 12 ]);
+    });
+});

test/spec/shim/media/QueueSetPropertiesRequest.spec.js

@@ -0,0 +1,13 @@
+"use strict";
+
+describe("chrome.cast.media.QueueSetPropertiesRequest", () => {
+    it("should have all properties", async () => {
+        const queueSetPropertiesRequest = new chrome.cast.media.QueueSetPropertiesRequest();
+
+        expect(queueSetPropertiesRequest.customData).toBe(null);
+        expect(queueSetPropertiesRequest.repeatMode).toBe(null);
+        expect(queueSetPropertiesRequest.requestId).toBe(null);
+        expect(queueSetPropertiesRequest.sessionId).toBe(null);
+        expect(queueSetPropertiesRequest.type).toBe("QUEUE_UPDATE");
+    });
+});

test/spec/shim/media/QueueUpdateItemsRequest.spec.js

@@ -0,0 +1,34 @@
+"use strict";
+
+describe("chrome.cast.media.QueueUpdateItemsRequest", () => {
+    it("should have all properties", async () => {
+        const queueUpdateItemsRequest = new chrome.cast.media.QueueUpdateItemsRequest();
+
+        expect(queueUpdateItemsRequest.customData).toBe(null);
+        expect(queueUpdateItemsRequest.items).toBe(undefined);
+        expect(queueUpdateItemsRequest.requestId).toBe(null);
+        expect(queueUpdateItemsRequest.sessionId).toBe(null);
+        expect(queueUpdateItemsRequest.type).toBe("QUEUE_UPDATE");
+    });
+
+    it("should have expected assigned properties", async () => {
+        const media1 = new chrome.cast.media.MediaInfo("media1", "video/mp4");
+        const media2 = new chrome.cast.media.MediaInfo("media2", "audio/mp3");
+
+        const queueUpdateItemsRequest = new chrome.cast.media.QueueUpdateItemsRequest([
+            new chrome.cast.media.QueueItem(media1)
+          , new chrome.cast.media.QueueItem(media2)
+        ]);
+
+        expect(queueUpdateItemsRequest.items).toEqual([
+            jasmine.objectContaining({ media: jasmine.objectContaining({
+                contentId: "media1"
+              , contentType: "video/mp4"
+            })})
+          , jasmine.objectContaining({ media: jasmine.objectContaining({
+                contentId: "media2"
+              , contentType: "audio/mp3"
+            })})
+        ]);
+    });
+});

test/spec/shim/media/SeekRequest.spec.js

@@ -0,0 +1,11 @@
+"use strict";
+
+describe("chrome.cast.media.SeekRequest", () => {
+    it("should have all properties", async () => {
+        const seekRequest = new chrome.cast.media.SeekRequest();
+
+        expect(seekRequest.currentTime).toBe(null);
+        expect(seekRequest.customData).toBe(null);
+        expect(seekRequest.resumeState).toBe(null);
+    });
+});

test/spec/shim/media/StopRequest.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+
+describe("chrome.cast.media.StopRequest", () => {
+    it("should have all properties", async () => {
+        const stopRequest = new chrome.cast.media.StopRequest();
+
+        expect(stopRequest.customData).toBe(null);
+    });
+});

test/spec/shim/media/TextTrackStyle.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+
+describe("chrome.cast.media.TextTrackStyle", () => {
+    it("should have all properties", async () => {
+        const textTrackStyle = new chrome.cast.media.TextTrackStyle();
+
+        expect(textTrackStyle.backgroundColor).toBe(null);
+        expect(textTrackStyle.customData).toBe(null);
+        expect(textTrackStyle.edgeColor).toBe(null);
+        expect(textTrackStyle.edgeType).toBe(null);
+        expect(textTrackStyle.fontFamily).toBe(null);
+        expect(textTrackStyle.fontGenericFamily).toBe(null);
+        expect(textTrackStyle.fontScale).toBe(null);
+        expect(textTrackStyle.fontStyle).toBe(null);
+        expect(textTrackStyle.foregroundColor).toBe(null);
+        expect(textTrackStyle.windowColor).toBe(null);
+        expect(textTrackStyle.windowRoundedCornerRadius).toBe(null);
+        expect(textTrackStyle.windowType).toBe(null);
+    });
+});

test/spec/shim/media/Track.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+
+describe("chrome.cast.media.Track", () => {
+    it("should have all properties", async () => {
+        const track = new chrome.cast.media.Track();
+
+        expect(track.customData).toBe(null);
+        expect(track.language).toBe(null);
+        expect(track.name).toBe(null);
+        expect(track.subtype).toBe(null);
+        expect(track.trackContentId).toBe(null);
+        expect(track.trackContentType).toBe(null);
+        expect(track.trackId).toBe(undefined);
+        expect(track.type).toBe(undefined);
+    });
+
+    it("should have expected assigned properties", async () => {
+        const track = new chrome.cast.media.Track(5, chrome.cast.media.TrackType.TEXT);
+
+        expect(track.trackId).toBe(5);
+        expect(track.type).toBe("TEXT");
+    });
+});

test/spec/shim/media/TvShowMediaMetadata.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+
+describe("chrome.cast.media.TvShowMediaMetadata", () => {
+    it("should have all properties", async () => {
+        const tvShowMediaMetadata = new chrome.cast.media.TvShowMediaMetadata();
+
+        expect(tvShowMediaMetadata.episode).toBe(null);
+        expect(tvShowMediaMetadata.episodeNumber).toBe(null);
+        expect(tvShowMediaMetadata.episodeTitle).toBe(null);
+        expect(tvShowMediaMetadata.images).toBe(null);
+        expect(tvShowMediaMetadata.metadataType).toBe(2);
+        expect(tvShowMediaMetadata.originalAirdate).toBe(null);
+        expect(tvShowMediaMetadata.releaseYear).toBe(null);
+        expect(tvShowMediaMetadata.season).toBe(null);
+        expect(tvShowMediaMetadata.seasonNumber).toBe(null);
+        expect(tvShowMediaMetadata.seriesTitle).toBe(null);
+        expect(tvShowMediaMetadata.title).toBe(null);
+        expect(tvShowMediaMetadata.type).toBe(2);
+    });
+});

test/spec/shim/media/VolumeRequest.spec.js

@@ -0,0 +1,20 @@
+"use strict";
+
+describe("chrome.cast.media.VolumeRequest", () => {
+    it("should have all properties", async () => {
+        const volumeRequest = new chrome.cast.media.VolumeRequest();
+
+        expect(volumeRequest.customData).toBe(null);
+        expect(volumeRequest.volume).toBe(undefined);
+    });
+
+    it("should have expected assigned properties", async () => {
+        const volume = new chrome.cast.Volume(0.5, false);
+        const volumeRequest = new chrome.cast.media.VolumeRequest(volume);
+
+        expect(volumeRequest.volume).toEqual(jasmine.objectContaining({
+            level: 0.5
+          , muted: false
+        }));
+    });
+});