2020-03-21 07:13:11 +01:00
|
|
|
package org.schabi.newpipe.extractor.services.youtube.search;
|
|
|
|
|
2022-03-20 20:55:04 +01:00
|
|
|
import static org.junit.jupiter.api.Assertions.assertEquals;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertFalse;
|
|
|
|
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
|
|
|
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;
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
import org.junit.jupiter.api.BeforeAll;
|
|
|
|
import org.junit.jupiter.api.Test;
|
2021-01-17 18:55:37 +01:00
|
|
|
import org.schabi.newpipe.downloader.DownloaderFactory;
|
2022-03-20 20:55:04 +01:00
|
|
|
import org.schabi.newpipe.downloader.MockOnly;
|
|
|
|
import org.schabi.newpipe.extractor.InfoItem;
|
|
|
|
import org.schabi.newpipe.extractor.ListExtractor;
|
|
|
|
import org.schabi.newpipe.extractor.MetaInfo;
|
|
|
|
import org.schabi.newpipe.extractor.NewPipe;
|
|
|
|
import org.schabi.newpipe.extractor.StreamingService;
|
2021-09-01 20:40:00 +02:00
|
|
|
import org.schabi.newpipe.extractor.channel.ChannelInfoItem;
|
|
|
|
import org.schabi.newpipe.extractor.exceptions.ExtractionException;
|
2020-03-21 07:13:11 +01:00
|
|
|
import org.schabi.newpipe.extractor.search.SearchExtractor;
|
|
|
|
import org.schabi.newpipe.extractor.services.DefaultSearchExtractorTest;
|
2022-02-07 21:23:38 +01:00
|
|
|
import org.schabi.newpipe.extractor.services.youtube.YoutubeTestsUtils;
|
2020-12-20 19:54:12 +01:00
|
|
|
import org.schabi.newpipe.extractor.stream.Description;
|
2021-09-01 20:40:00 +02:00
|
|
|
import org.schabi.newpipe.extractor.stream.StreamInfoItem;
|
2021-01-22 01:44:58 +01:00
|
|
|
|
|
|
|
import java.io.IOException;
|
2022-10-18 20:47:09 +02:00
|
|
|
import java.io.UnsupportedEncodingException;
|
2020-12-20 19:54:12 +01:00
|
|
|
import java.net.MalformedURLException;
|
|
|
|
import java.net.URL;
|
2022-10-18 20:47:09 +02:00
|
|
|
import java.net.URLEncoder;
|
2020-12-20 19:54:12 +01:00
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.List;
|
|
|
|
|
2022-03-20 20:55:04 +01:00
|
|
|
import javax.annotation.Nullable;
|
2020-03-21 07:13:11 +01:00
|
|
|
|
|
|
|
public class YoutubeSearchExtractorTest {
|
2021-01-17 18:55:37 +01:00
|
|
|
|
|
|
|
private static final String RESOURCE_PATH = DownloaderFactory.RESOURCE_PATH + "services/youtube/extractor/search/";
|
|
|
|
|
2020-03-21 07:13:11 +01:00
|
|
|
public static class All extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "test";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "all"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY);
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
}
|
|
|
|
|
|
|
|
public static class Channel extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "test";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "channel"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(CHANNELS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.CHANNEL; }
|
|
|
|
}
|
|
|
|
|
|
|
|
public static class Playlists extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "test";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "playlist"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(PLAYLISTS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.PLAYLIST; }
|
|
|
|
}
|
|
|
|
|
|
|
|
public static class Videos extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "test";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "videos"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.STREAM; }
|
|
|
|
}
|
|
|
|
|
2022-08-14 14:43:29 +02:00
|
|
|
/**
|
|
|
|
* Test for YT's "Did you mean...".
|
|
|
|
* <p>
|
|
|
|
* Hint: YT mostly shows "did you mean..." when you are searching in another language.
|
|
|
|
* </p>
|
|
|
|
*/
|
2022-03-20 20:55:04 +01:00
|
|
|
@MockOnly("Currently constantly switching between \"Did you mean\" and \"Showing results for ...\" occurs")
|
2020-03-21 07:13:11 +01:00
|
|
|
public static class Suggestion extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
2022-08-14 14:43:29 +02:00
|
|
|
private static final String QUERY = "algorythm";
|
|
|
|
private static final String EXPECTED_SUGGESTION = "algorithm";
|
2020-03-21 07:13:11 +01:00
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "suggestions"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return EXPECTED_SUGGESTION; }
|
2020-04-11 19:18:08 +02:00
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.STREAM; }
|
|
|
|
}
|
|
|
|
|
2022-08-14 14:43:29 +02:00
|
|
|
/**
|
|
|
|
* Test for YT's "Showing results for...".
|
|
|
|
*/
|
2020-04-11 19:18:08 +02:00
|
|
|
public static class CorrectedSearch extends DefaultSearchExtractorTest {
|
2020-03-21 07:13:11 +01:00
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "pewdeipie";
|
|
|
|
private static final String EXPECTED_SUGGESTION = "pewdiepie";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "corrected"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return EXPECTED_SUGGESTION; }
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.STREAM; }
|
2020-04-11 19:18:08 +02:00
|
|
|
@Override public boolean isCorrectedSearch() { return true; }
|
2020-03-21 07:13:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public static class RandomQueryNoMorePages extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "UCO6AK";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2020-03-21 07:13:11 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "random"));
|
2020-03-21 07:13:11 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY);
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
|
|
// Test Overrides
|
|
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testMoreRelatedItems() throws Exception {
|
2020-04-10 10:25:53 +02:00
|
|
|
final ListExtractor.InfoItemsPage<InfoItem> initialPage = extractor().getInitialPage();
|
2020-03-21 07:13:11 +01:00
|
|
|
// YouTube actually gives us an empty next page, but after that, no more pages.
|
2020-04-10 10:25:53 +02:00
|
|
|
assertTrue(initialPage.hasNextPage());
|
2020-04-15 14:09:46 +02:00
|
|
|
final ListExtractor.InfoItemsPage<InfoItem> nextEmptyPage = extractor.getPage(initialPage.getNextPage());
|
2020-03-21 07:13:11 +01:00
|
|
|
assertEquals(0, nextEmptyPage.getItems().size());
|
|
|
|
assertEmptyErrors("Empty page has errors", nextEmptyPage.getErrors());
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
assertFalse(nextEmptyPage.hasNextPage(), "More items available when it shouldn't");
|
2020-03-21 07:13:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public static class PagingTest {
|
|
|
|
@Test
|
|
|
|
public void duplicatedItemsCheck() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "paging"));
|
2020-03-21 07:13:11 +01:00
|
|
|
final SearchExtractor extractor = YouTube.getSearchExtractor("cirque du soleil", singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
|
|
|
|
final ListExtractor.InfoItemsPage<InfoItem> page1 = extractor.getInitialPage();
|
2020-04-15 14:09:46 +02:00
|
|
|
final ListExtractor.InfoItemsPage<InfoItem> page2 = extractor.getPage(page1.getNextPage());
|
2020-03-21 07:13:11 +01:00
|
|
|
|
|
|
|
assertNoDuplicatedItems(YouTube, page1, page2);
|
|
|
|
}
|
|
|
|
}
|
2020-12-20 19:54:12 +01:00
|
|
|
|
|
|
|
public static class MetaInfoTest extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "Covid";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "metaInfo"));
|
2020-12-20 19:54:12 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
@Override public List<MetaInfo> expectedMetaInfo() throws MalformedURLException {
|
|
|
|
return Collections.singletonList(new MetaInfo(
|
|
|
|
"COVID-19",
|
2022-07-30 15:07:49 +02:00
|
|
|
new Description(
|
|
|
|
"Get the latest information from the WHO about coronavirus.",
|
|
|
|
Description.PLAIN_TEXT),
|
|
|
|
Collections.singletonList(
|
|
|
|
new URL("https://www.who.int/emergencies/diseases/novel-coronavirus-2019")),
|
|
|
|
Collections.singletonList("LEARN MORE")
|
2020-12-20 19:54:12 +01:00
|
|
|
));
|
|
|
|
}
|
2021-07-05 19:22:25 +02:00
|
|
|
// testMoreRelatedItems is broken because a video has no duration shown
|
|
|
|
@Override public void testMoreRelatedItems() { }
|
2020-12-20 19:54:12 +01:00
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() throws Exception { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
}
|
2021-01-22 01:44:58 +01:00
|
|
|
|
|
|
|
public static class ChannelVerified extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "bbc";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2021-01-22 01:44:58 +01:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "verified"));
|
2021-01-22 01:44:58 +01:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(CHANNELS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.CHANNEL; }
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testAtLeastOneVerified() throws IOException, ExtractionException {
|
|
|
|
final List<InfoItem> items = extractor.getInitialPage().getItems();
|
|
|
|
boolean verified = false;
|
|
|
|
for (InfoItem item : items) {
|
|
|
|
if (((ChannelInfoItem) item).isVerified()) {
|
|
|
|
verified = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assertTrue(verified);
|
|
|
|
}
|
|
|
|
}
|
2021-09-01 20:40:00 +02:00
|
|
|
|
|
|
|
public static class VideoUploaderAvatar extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "sidemen";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2021-09-01 20:40:00 +02:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "video_uploader_avatar"));
|
2021-09-01 20:40:00 +02:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.STREAM; }
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testUploaderAvatar() throws IOException, ExtractionException {
|
|
|
|
final List<InfoItem> items = extractor.getInitialPage().getItems();
|
2021-09-01 21:05:56 +02:00
|
|
|
for (final InfoItem item : items) {
|
2021-09-01 20:40:00 +02:00
|
|
|
assertNotNull(((StreamInfoItem) item).getUploaderAvatarUrl());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-09-22 17:19:44 +02:00
|
|
|
|
|
|
|
public static class VideoDescription extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "44wLAzydRFU";
|
|
|
|
|
2021-12-27 21:08:08 +01:00
|
|
|
@BeforeAll
|
2021-09-22 17:19:44 +02:00
|
|
|
public static void setUp() throws Exception {
|
2022-02-07 21:23:38 +01:00
|
|
|
YoutubeTestsUtils.ensureStateless();
|
2022-03-16 17:22:42 +01:00
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "video_description"));
|
2021-09-22 17:19:44 +02:00
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + QUERY; }
|
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.STREAM; }
|
|
|
|
|
|
|
|
@Test
|
|
|
|
public void testVideoDescription() throws IOException, ExtractionException {
|
|
|
|
final List<InfoItem> items = extractor.getInitialPage().getItems();
|
|
|
|
assertNotNull(((StreamInfoItem) items.get(0)).getShortDescription());
|
|
|
|
}
|
|
|
|
}
|
2022-10-17 22:51:16 +02:00
|
|
|
|
|
|
|
public static class ShortFormContent extends DefaultSearchExtractorTest {
|
|
|
|
private static SearchExtractor extractor;
|
|
|
|
private static final String QUERY = "#shorts";
|
|
|
|
|
|
|
|
@BeforeAll
|
|
|
|
public static void setUp() throws Exception {
|
|
|
|
YoutubeTestsUtils.ensureStateless();
|
|
|
|
NewPipe.init(DownloaderFactory.getDownloader(RESOURCE_PATH + "shorts"));
|
|
|
|
extractor = YouTube.getSearchExtractor(QUERY, singletonList(VIDEOS), "");
|
|
|
|
extractor.fetchPage();
|
|
|
|
}
|
|
|
|
|
2022-10-18 20:47:09 +02:00
|
|
|
private String getUrlEncodedQuery() {
|
|
|
|
try {
|
|
|
|
return URLEncoder.encode(QUERY, "UTF-8");
|
|
|
|
} catch (UnsupportedEncodingException e) {
|
|
|
|
throw new RuntimeException(e);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-17 22:51:16 +02:00
|
|
|
@Override public SearchExtractor extractor() { return extractor; }
|
|
|
|
@Override public StreamingService expectedService() { return YouTube; }
|
|
|
|
@Override public String expectedName() { return QUERY; }
|
|
|
|
@Override public String expectedId() { return QUERY; }
|
2022-10-18 20:47:09 +02:00
|
|
|
@Override public String expectedUrlContains() { return "youtube.com/results?search_query=" + getUrlEncodedQuery(); }
|
|
|
|
@Override public String expectedOriginalUrlContains() { return "youtube.com/results?search_query=" + getUrlEncodedQuery(); }
|
2022-10-17 22:51:16 +02:00
|
|
|
@Override public String expectedSearchString() { return QUERY; }
|
|
|
|
@Nullable @Override public String expectedSearchSuggestion() { return null; }
|
|
|
|
@Override public InfoItem.InfoType expectedInfoItemType() { return InfoItem.InfoType.STREAM; }
|
|
|
|
|
|
|
|
@Test
|
2022-10-18 02:05:16 +02:00
|
|
|
public void testShortFormContent() throws IOException, ExtractionException {
|
2022-10-17 22:51:16 +02:00
|
|
|
final List<InfoItem> items = extractor.getInitialPage().getItems();
|
|
|
|
boolean hasShortFormContent = false;
|
|
|
|
for (InfoItem item : items) {
|
|
|
|
if (((StreamInfoItem) item).isShortFormContent()) {
|
|
|
|
hasShortFormContent = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
assertTrue(hasShortFormContent);
|
|
|
|
}
|
|
|
|
}
|
2020-03-21 07:13:11 +01:00
|
|
|
}
|