From 8280fd4a60f2a3b783f9a2ecfbedfc6dbde0f262 Mon Sep 17 00:00:00 2001 From: evermind Date: Tue, 11 Oct 2022 14:30:47 +0200 Subject: [PATCH] searchfilters: Test: adjust and extend YouTube tests --- .../YoutubeMusicSearchExtractorTest.java | 30 ++- .../search/YoutubeSearchExtractorTest.java | 38 ++- .../youtube/search/YoutubeSearchQHTest.java | 95 ++++--- ...rotoBufferSearchParameterAccessorTest.java | 252 ++++++++++++++++++ 4 files changed, 358 insertions(+), 57 deletions(-) create mode 100644 extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/filter/YoutubeProtoBufferSearchParameterAccessorTest.java diff --git a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeMusicSearchExtractorTest.java b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeMusicSearchExtractorTest.java index 390fcbec1..6e738229b 100644 --- a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeMusicSearchExtractorTest.java +++ b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeMusicSearchExtractorTest.java @@ -10,8 +10,10 @@ import org.schabi.newpipe.extractor.InfoItem; import org.schabi.newpipe.extractor.NewPipe; import org.schabi.newpipe.extractor.StreamingService; import org.schabi.newpipe.extractor.search.SearchExtractor; +import org.schabi.newpipe.extractor.search.filter.FilterItem; import org.schabi.newpipe.extractor.services.DefaultSearchExtractorTest; import org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory; +import org.schabi.newpipe.extractor.services.youtube.search.filter.YoutubeFilters; import java.net.URLEncoder; @@ -26,7 +28,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_SONGS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -48,7 +52,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_VIDEOS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -70,7 +76,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_ALBUMS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_ALBUMS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -92,7 +100,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_PLAYLISTS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_PLAYLISTS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -115,7 +125,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_ARTISTS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_ARTISTS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -139,7 +151,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_SONGS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -163,7 +177,9 @@ public class YoutubeMusicSearchExtractorTest { @BeforeAll public static void setUp() throws Exception { NewPipe.init(DownloaderTestImpl.getInstance()); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(YoutubeSearchQueryHandlerFactory.MUSIC_SONGS), ""); + final FilterItem item = + getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } diff --git a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchExtractorTest.java b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchExtractorTest.java index 7612ec06c..b91478c55 100644 --- a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchExtractorTest.java +++ b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchExtractorTest.java @@ -7,9 +7,6 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.schabi.newpipe.extractor.ExtractorAsserts.assertEmptyErrors; import static org.schabi.newpipe.extractor.ServiceList.YouTube; import static org.schabi.newpipe.extractor.services.DefaultTests.assertNoDuplicatedItems; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.CHANNELS; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.PLAYLISTS; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.VIDEOS; import static java.util.Collections.singletonList; import org.junit.jupiter.api.BeforeAll; @@ -23,8 +20,10 @@ import org.schabi.newpipe.extractor.StreamingService; import org.schabi.newpipe.extractor.channel.ChannelInfoItem; import org.schabi.newpipe.extractor.exceptions.ExtractionException; import org.schabi.newpipe.extractor.search.SearchExtractor; +import org.schabi.newpipe.extractor.search.filter.FilterItem; import org.schabi.newpipe.extractor.services.DefaultSearchExtractorTest; import org.schabi.newpipe.extractor.services.youtube.YoutubeTestsUtils; +import org.schabi.newpipe.extractor.services.youtube.search.filter.YoutubeFilters; import org.schabi.newpipe.extractor.stream.Description; import org.schabi.newpipe.extractor.stream.StreamInfoItem; import org.schabi.newpipe.extractor.utils.Utils; @@ -71,7 +70,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "channel")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(CHANNELS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_CHANNELS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -95,7 +95,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "playlist")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(PLAYLISTS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_PLAYLISTS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -119,7 +120,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "videos")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -151,7 +153,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "suggestions")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -178,7 +181,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "corrected")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -237,7 +241,10 @@ public class YoutubeSearchExtractorTest { void duplicatedItemsCheck() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "paging")); - final SearchExtractor extractor = YouTube.getSearchExtractor("cirque du soleil", singletonList(VIDEOS), ""); + + final FilterItem item = DefaultSearchExtractorTest.getFilterItem( + YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + final SearchExtractor extractor = YouTube.getSearchExtractor("cirque du soleil", singletonList(item), null); extractor.fetchPage(); final ListExtractor.InfoItemsPage page1 = extractor.getInitialPage(); @@ -255,7 +262,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "metaInfo")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -290,7 +298,9 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "verified")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(CHANNELS), ""); + + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_CHANNELS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -327,7 +337,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "video_uploader_avatar")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } @@ -361,7 +372,8 @@ public class YoutubeSearchExtractorTest { public static void setUp() throws Exception { YoutubeTestsUtils.ensureStateless(); NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "video_description")); - extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), ""); + final FilterItem item = getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + extractor = YouTube.getSearchExtractor(QUERY, singletonList(item), null); extractor.fetchPage(); } diff --git a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchQHTest.java b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchQHTest.java index 0b9937f3e..33e8d4269 100644 --- a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchQHTest.java +++ b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/YoutubeSearchQHTest.java @@ -1,75 +1,96 @@ package org.schabi.newpipe.extractor.services.youtube.search; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.schabi.newpipe.extractor.ServiceList.YouTube; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.CHANNELS; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.MUSIC_SONGS; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.PLAYLISTS; -import static org.schabi.newpipe.extractor.services.youtube.linkHandler.YoutubeSearchQueryHandlerFactory.VIDEOS; -import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; import org.junit.jupiter.api.Test; +import org.schabi.newpipe.extractor.search.filter.FilterContainer; +import org.schabi.newpipe.extractor.search.filter.FilterItem; +import org.schabi.newpipe.extractor.services.DefaultSearchExtractorTest; +import org.schabi.newpipe.extractor.services.youtube.search.filter.YoutubeFilters; public class YoutubeSearchQHTest { @Test - public void testRegularValues() throws Exception { + public void testDefaultSearch() throws Exception { assertEquals("https://www.youtube.com/results?search_query=asdf&sp=8AEB", YouTube.getSearchQHFactory().fromQuery("asdf").getUrl()); assertEquals("https://www.youtube.com/results?search_query=hans&sp=8AEB", YouTube.getSearchQHFactory().fromQuery("hans").getUrl()); assertEquals("https://www.youtube.com/results?search_query=Poifj%26jaijf&sp=8AEB", YouTube.getSearchQHFactory().fromQuery("Poifj&jaijf").getUrl()); assertEquals("https://www.youtube.com/results?search_query=G%C3%BCl%C3%BCm&sp=8AEB", YouTube.getSearchQHFactory().fromQuery("Gülüm").getUrl()); assertEquals("https://www.youtube.com/results?search_query=%3Fj%24%29H%C2%A7B&sp=8AEB", YouTube.getSearchQHFactory().fromQuery("?j$)H§B").getUrl()); + } - assertEquals("https://music.youtube.com/search?q=asdf", YouTube.getSearchQHFactory().fromQuery("asdf", asList(new String[]{MUSIC_SONGS}), "").getUrl()); - assertEquals("https://music.youtube.com/search?q=hans", YouTube.getSearchQHFactory().fromQuery("hans", asList(new String[]{MUSIC_SONGS}), "").getUrl()); - assertEquals("https://music.youtube.com/search?q=Poifj%26jaijf", YouTube.getSearchQHFactory().fromQuery("Poifj&jaijf", asList(new String[]{MUSIC_SONGS}), "").getUrl()); - assertEquals("https://music.youtube.com/search?q=G%C3%BCl%C3%BCm", YouTube.getSearchQHFactory().fromQuery("Gülüm", asList(new String[]{MUSIC_SONGS}), "").getUrl()); - assertEquals("https://music.youtube.com/search?q=%3Fj%24%29H%C2%A7B", YouTube.getSearchQHFactory().fromQuery("?j$)H§B", asList(new String[]{MUSIC_SONGS}), "").getUrl()); + @Test + public void testMusicSongsSearch() throws Exception { + final FilterItem item = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS); + assertEquals("https://music.youtube.com/search?q=asdf", YouTube.getSearchQHFactory().fromQuery("asdf", singletonList(item), null).getUrl()); + assertEquals("https://music.youtube.com/search?q=hans", YouTube.getSearchQHFactory().fromQuery("hans", singletonList(item), null).getUrl()); + assertEquals("https://music.youtube.com/search?q=Poifj%26jaijf", YouTube.getSearchQHFactory().fromQuery("Poifj&jaijf", singletonList(item), null).getUrl()); + assertEquals("https://music.youtube.com/search?q=G%C3%BCl%C3%BCm", YouTube.getSearchQHFactory().fromQuery("Gülüm", singletonList(item), null).getUrl()); + assertEquals("https://music.youtube.com/search?q=%3Fj%24%29H%C2%A7B", YouTube.getSearchQHFactory().fromQuery("?j$)H§B", singletonList(item), null).getUrl()); } @Test public void testGetContentFilter() throws Exception { - assertEquals(VIDEOS, YouTube.getSearchQHFactory() - .fromQuery("", asList(new String[]{VIDEOS}), "").getContentFilters().get(0)); - assertEquals(CHANNELS, YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{CHANNELS}), "").getContentFilters().get(0)); + final FilterItem videoFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + final FilterItem channelsFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_CHANNELS); + assertEquals(YoutubeFilters.ID_CF_MAIN_VIDEOS, YouTube.getSearchQHFactory() + .fromQuery("", singletonList(videoFilterItem), null).getContentFilters().get(0).getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_CHANNELS, YouTube.getSearchQHFactory() + .fromQuery("asdf", singletonList(channelsFilterItem), null).getContentFilters().get(0).getIdentifier()); - assertEquals(MUSIC_SONGS, YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{MUSIC_SONGS}), "").getContentFilters().get(0)); + final FilterItem musicSongsFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS); + assertEquals(YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS, YouTube.getSearchQHFactory() + .fromQuery("asdf", singletonList(musicSongsFilterItem), null).getContentFilters().get(0).getIdentifier()); } @Test public void testWithContentfilter() throws Exception { - assertEquals("https://www.youtube.com/results?search_query=asdf&sp=EgIQAfABAQ%253D%253D", YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{VIDEOS}), "").getUrl()); - assertEquals("https://www.youtube.com/results?search_query=asdf&sp=EgIQAvABAQ%253D%253D", YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{CHANNELS}), "").getUrl()); - assertEquals("https://www.youtube.com/results?search_query=asdf&sp=EgIQA_ABAQ%253D%253D", YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{PLAYLISTS}), "").getUrl()); + final FilterItem videoFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_VIDEOS); + final FilterItem channelsFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_CHANNELS); + final FilterItem playlistsFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_PLAYLISTS); + final FilterItem musicSongsFilterItem = DefaultSearchExtractorTest.getFilterItem(YouTube, YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS); + assertEquals("https://www.youtube.com/results?search_query=asdf&sp=EgIQAfABAQ%3D%3D", YouTube.getSearchQHFactory() + .fromQuery("asdf", singletonList(videoFilterItem), null).getUrl()); + assertEquals("https://www.youtube.com/results?search_query=asdf&sp=EgIQAvABAQ%3D%3D", YouTube.getSearchQHFactory() + .fromQuery("asdf", singletonList(channelsFilterItem), null).getUrl()); + assertEquals("https://www.youtube.com/results?search_query=asdf&sp=EgIQA_ABAQ%3D%3D", YouTube.getSearchQHFactory() + .fromQuery("asdf", singletonList(playlistsFilterItem), null).getUrl()); assertEquals("https://www.youtube.com/results?search_query=asdf&sp=8AEB", YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{"fjiijie"}), "").getUrl()); + .fromQuery("asdf", singletonList(null), null).getUrl()); assertEquals("https://music.youtube.com/search?q=asdf", YouTube.getSearchQHFactory() - .fromQuery("asdf", asList(new String[]{MUSIC_SONGS}), "").getUrl()); + .fromQuery("asdf", singletonList(musicSongsFilterItem), null).getUrl()); } @Test public void testGetAvailableContentFilter() { - final String[] contentFilter = YouTube.getSearchQHFactory().getAvailableContentFilter(); - assertEquals(8, contentFilter.length); - assertEquals("all", contentFilter[0]); - assertEquals("videos", contentFilter[1]); - assertEquals("channels", contentFilter[2]); - assertEquals("playlists", contentFilter[3]); - assertEquals("music_songs", contentFilter[4]); - assertEquals("music_videos", contentFilter[5]); - assertEquals("music_albums", contentFilter[6]); - assertEquals("music_playlists", contentFilter[7]); + final FilterContainer contentFilter = + YouTube.getSearchQHFactory().getAvailableContentFilter(); + + final int noOfContentFilters = DefaultSearchExtractorTest.getNoOfFilterItems(contentFilter); + final FilterItem[] filterItems = contentFilter.getFilterGroups()[0].getFilterItems(); + assertEquals(10, noOfContentFilters); + assertEquals(YoutubeFilters.ID_CF_MAIN_ALL, filterItems[0].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_VIDEOS, filterItems[1].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_CHANNELS, filterItems[2].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_PLAYLISTS, filterItems[3].getIdentifier()); + assertTrue(filterItems[4] instanceof FilterItem.DividerItem); + assertEquals(YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_SONGS, filterItems[5].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_VIDEOS, filterItems[6].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_ALBUMS, filterItems[7].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_PLAYLISTS, filterItems[8].getIdentifier()); + assertEquals(YoutubeFilters.ID_CF_MAIN_YOUTUBE_MUSIC_ARTISTS, filterItems[9].getIdentifier()); } @Test public void testGetAvailableSortFilter() { - final String[] contentFilter = YouTube.getSearchQHFactory().getAvailableSortFilter(); - assertEquals(0, contentFilter.length); + final FilterContainer contentFilterContainer = + YouTube.getSearchQHFactory().getAvailableContentFilter(); + final int noOfSortFilters = + DefaultSearchExtractorTest.getNoOfSortFilterItems(contentFilterContainer); + assertEquals(24, noOfSortFilters); } } diff --git a/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/filter/YoutubeProtoBufferSearchParameterAccessorTest.java b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/filter/YoutubeProtoBufferSearchParameterAccessorTest.java new file mode 100644 index 000000000..93eed0f22 --- /dev/null +++ b/extractor/src/test/java/org/schabi/newpipe/extractor/services/youtube/search/filter/YoutubeProtoBufferSearchParameterAccessorTest.java @@ -0,0 +1,252 @@ +// Created by evermind-zz 2022, licensed GNU GPL version 3 or later + +package org.schabi.newpipe.extractor.services.youtube.search.filter; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.schabi.newpipe.extractor.services.youtube.search.filter.protobuf.DateFilter; +import org.schabi.newpipe.extractor.services.youtube.search.filter.protobuf.Features; +import org.schabi.newpipe.extractor.services.youtube.search.filter.protobuf.LengthFilter; +import org.schabi.newpipe.extractor.services.youtube.search.filter.protobuf.SearchRequest; +import org.schabi.newpipe.extractor.services.youtube.search.filter.protobuf.SortOrder; +import org.schabi.newpipe.extractor.services.youtube.search.filter.protobuf.TypeFilter; + +import java.io.IOException; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class YoutubeProtoBufferSearchParameterAccessorTest { + + final DateFilter[] dateFilters = { + DateFilter.hour, + DateFilter.day, + DateFilter.week, + DateFilter.month, + DateFilter.year + }; + final SortOrder[] sortOrders = { + SortOrder.relevance, + SortOrder.rating, + SortOrder.date, + SortOrder.views + }; + final LengthFilter[] lengthFilters = { + LengthFilter.duration_short, + LengthFilter.duration_long, + LengthFilter.duration_medium + }; + final TypeFilter[] typeFilters = { + TypeFilter.video, + TypeFilter.channel, + TypeFilter.playlist, + TypeFilter.movie, + TypeFilter.show + }; + final Features[] features = { + Features.live, + Features.is_4k, + Features.is_hd, + Features.subtitles, + Features.ccommons, + Features.is_360, + Features.is_vr180, + Features.is_3d, + Features.is_hdr, + Features.location, + Features.purchased + }; + YoutubeProtoBufferSearchParameterAccessor.Builder spBuilder; + + @BeforeEach + void setUp() { + spBuilder = new YoutubeProtoBufferSearchParameterAccessor.Builder(); + } + + @AfterEach + void tearDown() { + spBuilder = null; + } + + @Test + void dateFilterTest() throws IOException { + + for (final DateFilter dateFilter : dateFilters) { + spBuilder.setDateFilter(dateFilter); + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + assertEquals(dateFilter.getValue(), decodedSp.filter.date); + } + } + + @Test + void sortFilterTest() throws IOException { + for (final SortOrder sortOrder : sortOrders) { + spBuilder.setSortOrder(sortOrder); + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + assertEquals(sortOrder.getValue(), decodedSp.sorted); + } + } + + @Test + void typeFilterTest() throws IOException { + for (final TypeFilter type : typeFilters) { + spBuilder.setTypeFilter(type); + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + assertEquals(type.getValue(), decodedSp.filter.type); + } + } + + @Test + void lengthFilterTest() throws IOException { + for (final LengthFilter length : lengthFilters) { + spBuilder.setLengthFilter(length); + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + assertEquals(length.getValue(), decodedSp.filter.length); + } + } + + // All filters/features disabled. + @Test + void noneDateSortTypeLengthFeaturesSetTest() throws IOException { + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + + assertNull(decodedSp.filter.date); + assertNull(decodedSp.filter.type); + assertNull(decodedSp.sorted); + assertNull(decodedSp.filter.length); + for (final Features feature : features) { + assertFalse(getFeatureState(feature, decodedSp)); + } + } + + @Test + void featuresOneAtATimeTest() throws IOException { + for (final Features feature : features) { + spBuilder.addFeature(feature); + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + assertTrue(getFeatureState(feature, decodedSp)); + spBuilder = new YoutubeProtoBufferSearchParameterAccessor.Builder(); + } + } + + @Test + void allFeaturesSetTest() throws IOException { + for (final Features feature : features) { + spBuilder.addFeature(feature); + } + + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + + for (final Features feature : features) { + assertTrue(getFeatureState(feature, decodedSp)); + } + } + + @Test + void allOptionsSelectedOnceTesting() throws IOException { + for (final Features feature : features) { + spBuilder = new YoutubeProtoBufferSearchParameterAccessor.Builder(); + spBuilder.addFeature(feature); + + for (final SortOrder sortOrder : sortOrders) { + spBuilder.setSortOrder(sortOrder); + + for (final TypeFilter type : typeFilters) { + spBuilder.setTypeFilter(type); + + for (final LengthFilter length : lengthFilters) { + spBuilder.setLengthFilter(length); + + for (final DateFilter dateFilter : dateFilters) { + spBuilder.setDateFilter(dateFilter); + final YoutubeProtoBufferSearchParameterAccessor what = + spBuilder.build(); + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + + assertEquals(dateFilter.getValue(), decodedSp.filter.date); + assertEquals(type.getValue(), decodedSp.filter.type); + assertEquals(sortOrder.getValue(), decodedSp.sorted); + assertEquals(length.getValue(), decodedSp.filter.length); + assertTrue(getFeatureState(feature, decodedSp)); + } + } + } + } + } + } + + @Test + @Disabled("This is not a real test case but to evaluate new features") + void oneFeaturesSetTest() throws IOException { + spBuilder.addFeature(Features.is_vr180); + + final YoutubeProtoBufferSearchParameterAccessor what = spBuilder.build(); + //final String encodedSp = "EgPQAQE%3D"; + final String encodedSp = what.getSp(); + final SearchRequest decodedSp = what.decodeSp(encodedSp); + } + + // helpers + private boolean getFeatureState(final Features feature, final SearchRequest decodedSp) { + final Optional state; + switch (feature) { + case live: + state = Optional.ofNullable(decodedSp.filter.live); + break; + case is_4k: + state = Optional.ofNullable(decodedSp.filter.is_4k); + break; + case is_hd: + state = Optional.ofNullable(decodedSp.filter.is_hd); + break; + case subtitles: + state = Optional.ofNullable(decodedSp.filter.subtitles); + break; + case ccommons: + state = Optional.ofNullable(decodedSp.filter.ccommons); + break; + case is_360: + state = Optional.ofNullable(decodedSp.filter.is_360); + break; + case is_vr180: + state = Optional.ofNullable(decodedSp.filter.is_vr180); + break; + case is_3d: + state = Optional.ofNullable(decodedSp.filter.is_3d); + break; + case is_hdr: + state = Optional.ofNullable(decodedSp.filter.is_hdr); + break; + case location: + state = Optional.ofNullable(decodedSp.filter.location); + break; + case purchased: + state = Optional.ofNullable(decodedSp.filter.purchased); + break; + default: + state = Optional.empty(); + } + + return state.orElse(false); + } +}