Merge pull request #37 from AB1908/test

Add tests

src/tests/ParameterizedAPI.test.ts

@@ -0,0 +1,110 @@
+import fetchMock, { enableFetchMocks } from 'jest-fetch-mock';
+import { MediaDbPluginSettings } from 'src/settings/Settings';
+import { LocGovAPI } from '../api/apis/LocGovAPI';
+import { MALAPI } from '../api/apis/MALAPI';
+import { MusicBrainzAPI } from '../api/apis/MusicBrainzAPI';
+import { OMDbAPI } from '../api/apis/OMDbAPI';
+import { SteamAPI } from '../api/apis/SteamAPI';
+import { WikipediaAPI } from '../api/apis/WikipediaAPI';
+import MediaDbPlugin from '../main';
+import { setMALResponseMock, setMusicBrainzResponseMock, setOMDbResponseMock, setSteamResponseMock, setWikipediaResponseMock } from "./mockHelpers";
+import MALMockMovie from "./ResponseMocks/MALMockMovie.json";
+import MusicBrainzResponseMock from "./ResponseMocks/MusicBrainzMockResponse.json";
+import OMDBMockMovie from "./ResponseMocks/OMDBMockResponse.json";
+import SteamAPIResponseMock from "./ResponseMocks/SteamAPIMockResponse.json";
+import WikipediaMockResponse from "./ResponseMocks/WikipediaMockResponse.json";
+
+enableFetchMocks();
+export let apiMock: OMDbAPI | MALAPI | LocGovAPI | MusicBrainzAPI | SteamAPI | WikipediaAPI;
+
+describe.each(
+	[
+		{ name: OMDbAPI },
+		{ name: MALAPI },
+		{ name: LocGovAPI },
+		{ name: MusicBrainzAPI },
+		{ name: SteamAPI },
+		{ name: WikipediaAPI }
+	]
+)('$name.name', ({ name: parameterizedApi }) => {
+	beforeAll(() => {
+		let settingsMock: MediaDbPluginSettings = {} as MediaDbPluginSettings;
+		let pluginMock = {} as MediaDbPlugin;
+		pluginMock.settings = settingsMock;
+		// TODO: add fake API key?
+		apiMock = new parameterizedApi(pluginMock);
+	})
+
+	beforeEach(() => {
+		fetchMock.resetMocks();
+	})
+
+	test("searchByTitle behavior when API returns garbage data", async () => {
+		const garbageResponse = JSON.stringify({
+			data: "string"
+		});
+		fetchMock.mockResponseOnce(garbageResponse)
+		await expect(apiMock.searchByTitle("sample")).resolves.toEqual([]);
+		// }
+		expect(fetch).toHaveBeenCalledTimes(1);
+	});
+
+	test("searchByTitle behavior when requestUrl/fetch returns 401", async () => {
+		let sampleResponse = {
+			data: "string"
+		};
+		fetchMock.mockResponse(JSON.stringify(sampleResponse), { status: 401 });
+		// TODO: Check API name and fix message
+		// TODO: Externalize string
+		await expect(apiMock.searchByTitle("sample")).rejects.toThrow(`MDB | Received status code ${401} from an API.`);
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+	});
+
+	test("searchByTitle behavior when requestUrl/fetch returns 403", async () => {
+		let sampleResponse = {
+			data: "string"
+		};
+		fetchMock.mockResponse(JSON.stringify(sampleResponse), { status: 403 });
+		// TODO: Check API name and fix message
+		// TODO: Externalize string/import?
+		await expect(apiMock.searchByTitle("sample")).rejects.toThrow(`MDB | Received status code ${403} from an API.`);
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+	});
+
+	test("searchByTitle behavior when requestUrl/fetch returns 200", async () => {
+		let sampleResponse;
+		let ret;
+		switch (parameterizedApi) {
+			case OMDbAPI:
+				ret = setOMDbResponseMock();
+				sampleResponse = OMDBMockMovie;
+				break;
+			case WikipediaAPI:
+				ret = setWikipediaResponseMock();
+				sampleResponse = WikipediaMockResponse;
+				break;
+			case MALAPI:
+				// TODO: MAL needs more tests for different types of content
+				ret = setMALResponseMock();
+				sampleResponse = MALMockMovie;
+			case LocGovAPI:
+				// TODO: Add soon
+				break;
+			case SteamAPI:
+				sampleResponse = SteamAPIResponseMock;
+				ret = setSteamResponseMock();
+				break;
+			case MusicBrainzAPI:
+				sampleResponse = MusicBrainzResponseMock;
+				ret = setMusicBrainzResponseMock();
+				break;
+			default:
+				throw Error();
+		}
+		fetchMock.mockResponse(JSON.stringify(sampleResponse), { status: 200 });
+		// TODO: Check API name and fix message
+		// TODO: Externalize string
+		await expect(apiMock.searchByTitle("Hooking Season Playtest")).resolves.toEqual(ret);
+		expect(fetchMock).toHaveBeenCalledTimes(1);
+	});
+})

src/tests/ResponseMocks/MALMockMovie.json

@@ -0,0 +1,30 @@
+{
+	"data": [
+		{
+			"mal_id": 2890,
+			"url": "https://myanimelist.net/anime/2890/Gake_no_Ue_no_Ponyo",
+			"title": "Gake no Ue no Ponyo",
+			"title_english": "Ponyo",
+			"type": "Movie",
+			"source": "Original",
+			"episodes": 1,
+			"aired": {
+				"from": "2008-07-19T00:00:00+00:00",
+				"to": null,
+				"prop": {
+					"from": {
+						"day": 19,
+						"month": 7,
+						"year": 2008
+					},
+					"to": {
+						"day": null,
+						"month": null,
+						"year": null
+					}
+				},
+				"string": "Jul 19, 2008"
+			}
+		}
+	]
+}

src/tests/ResponseMocks/MusicBrainzMockResponse.json

@@ -0,0 +1,25 @@
+{
+    "release-groups": [
+        {
+            "id": "9cf08bf9-1948-4087-abe1-783210ea1fae",
+            "primary-type-id": "f529b476-6e62-324f-b0aa-1f3e33d313fc",
+            "title": "Halo Halo",
+            "first-release-date": "2013-07-08",
+            "primary-type": "Album",
+            "artist-credit": [
+                {
+                    "name": "Halo Halo",
+                    "artist": {
+                        "name": "Halo Halo"
+                    }
+                }
+            ],
+            "releases": [
+                {
+                    "id": "58dd1d57-2201-472e-9e36-5d497dcedb6f",
+                    "title": "Halo Halo"
+                }
+            ]
+        }
+    ]
+}

src/tests/ResponseMocks/OMDBMockResponse.json

@@ -0,0 +1,13 @@
+{
+	"Search": [
+		{
+			"Title": "Guardians of the Galaxy",
+			"Year": "2014",
+			"imdbID": "tt2015381",
+			"Type": "movie",
+			"Poster": "https://m.media-amazon.com/images/M/MV5BMTAwMjU5OTgxNjZeQTJeQWpwZ15BbWU4MDUxNDYxODEx._V1_SX300.jpg"
+		}
+    ],
+	"totalResults": "1",
+	"Response": "True"
+}

src/tests/ResponseMocks/SteamAPIMockResponse.json

@@ -0,0 +1,14 @@
+{
+    "applist": {
+        "apps": [
+            {
+                "appid": 2076590,
+                "name": "Hooking Season Playtest"
+            },
+            {
+                "appid": 2076600,
+                "name": "MonsterTamer"
+            }
+        ]
+    }
+}

src/tests/ResponseMocks/WikipediaMockResponse.json

@@ -0,0 +1,20 @@
+{
+    "query": {
+        "searchinfo": {
+            "totalhits": 1199001,
+            "suggestion": "book",
+            "suggestionsnippet": "book"
+        },
+        "search": [
+            {
+                "ns": 0,
+                "title": "Book",
+                "pageid": 3778,
+                "size": 68829,
+                "wordcount": 8821,
+                "snippet": "called <span class=\"searchmatch\">books</span> or chapters or parts, are parts. The intellectual content in a physical book need not be a composition, nor even be called a book. <span class=\"searchmatch\">Books</span> can",
+                "timestamp": "2022-08-19T19:13:56Z"
+            }
+        ]
+    }
+}

src/tests/mockHelpers.ts

@@ -0,0 +1,87 @@
+import { GameModel } from "../models/GameModel";
+import { MovieModel } from '../models/MovieModel';
+import { MusicReleaseModel } from "../models/MusicReleaseModel";
+import { WikiModel } from '../models/WikiModel';
+import { MediaType } from "../utils/MediaType";
+import { apiMock } from "./ParameterizedAPI.test";
+import MALMockMovie from "./ResponseMocks/MALMockMovie.json";
+import MusicBrainzResponseMock from "./ResponseMocks/MusicBrainzMockResponse.json";
+import OMDBMockMovie from "./ResponseMocks/OMDBMockResponse.json";
+import SteamAPIResponseMock from "./ResponseMocks/SteamAPIMockResponse.json";
+import WikipediaMockResponse from "./ResponseMocks/WikipediaMockResponse.json";
+
+export function setWikipediaResponseMock() {
+	let ret = [];
+	let wikiresponse = WikipediaMockResponse.query.search[0];
+	ret.push(new WikiModel({
+		type: 'wiki',
+		title: wikiresponse.title,
+		englishTitle: wikiresponse.title,
+		year: '',
+		dataSource: apiMock.apiName,
+		id: wikiresponse.pageid,
+	}));
+	return ret;
+}
+
+export function setOMDbResponseMock() {
+	let ret = [];
+	let omdbresponse = OMDBMockMovie.Search[0];
+	ret.push(new MovieModel({
+		type: 'wiki',
+		title: omdbresponse.Title,
+		englishTitle: omdbresponse.Title,
+		year: omdbresponse.Year,
+		dataSource: apiMock.apiName,
+		id: omdbresponse.imdbID,
+	}));
+	return ret;
+}
+
+export function setMALResponseMock() {
+	let ret = [];
+	let result = MALMockMovie.data[0];
+	ret.push(new MovieModel({
+		type: result.type,
+		title: result.title,
+		englishTitle: result.title_english,
+		year: result.aired.prop.from.year,
+		dataSource: apiMock.apiName,
+		id: result.mal_id,
+	}));
+	return ret;
+}
+
+export function setSteamResponseMock() {
+	let ret = [];
+	let steamResponse = SteamAPIResponseMock.applist.apps[0];
+	ret.push(
+		new GameModel({
+			type: MediaType.Game,
+			title: steamResponse.name,
+			englishTitle: steamResponse.name,
+			year: '',
+			dataSource: apiMock.apiName,
+			id: steamResponse.appid,
+		})
+	)
+	return ret;
+}
+
+export function setMusicBrainzResponseMock() {
+	let ret = [];
+	let result = MusicBrainzResponseMock["release-groups"][0];
+			ret.push(new MusicReleaseModel({
+				type: 'musicRelease',
+				title: result.title,
+				englishTitle: result.title,
+				year: (new Date(result['first-release-date'])).getFullYear().toString(),
+				dataSource: apiMock.apiName,
+				url: '',
+				id: result.id,
+
+				artists: result['artist-credit'].map((a: any) => a.name),
+				subType: result['primary-type'],
+			} as MusicReleaseModel));
+	return ret;
+}

src/tests/utils.test.ts

@@ -0,0 +1,24 @@
+import { wrapAround, containsOnlyLettersAndUnderscores, replaceIllegalFileNameCharactersInString} from '../utils/Utils';
+
+test('If wrapAround wraps correctly', () => {
+    expect(wrapAround(100,5)).toBe(0);
+    expect(wrapAround(100,7)).toBe(2);
+});
+
+test('If wrapAround errors out when dividing by zero', () => {
+    expect(wrapAround(100,0)).toThrow();
+});
+
+test('Letter and underscore string validity', () => {
+    expect(containsOnlyLettersAndUnderscores("asdkfj_")).toBe(true);
+    expect(containsOnlyLettersAndUnderscores("asdkfj0")).toBe(false);
+});
+
+test('Letter and underscore unicode char test', () =>{ 
+    expect(containsOnlyLettersAndUnderscores("asdkaÈj")).toBe(true);
+    expect(containsOnlyLettersAndUnderscores("asdkaÈj0")).toBe(false);
+});
+
+test('Valid filename test', ()=>{
+    expect(replaceIllegalFileNameCharactersInString("what?is\\this:")).toBe("whatisthis -");
+})