Add testing interface, including a set of capabilities to tests for

config/checkstyle/checkstyle.xml

@@ -12,7 +12,9 @@
 
     <!-- BeforeExecutionFileFilters is required for sources that are based on java14 -->
     <module name="BeforeExecutionExclusionFileFilter">
-      <property name="fileNamePattern" value="AuthorAndsReplacer.java|EntryTypeView.java|MainTableFieldValueFormatter.java|Ordinal.java" />
+        <property
+                name="fileNamePattern"
+                value="AuthorAndsReplacer.java|EntryTypeView.java|IEEE.java|MainTableFieldValueFormatter.java|Ordinal.java"/>
     </module>
 
     <module name="SuppressionFilter">

src/main/java/org/jabref/logic/importer/AdvancedFetcher.java

@@ -0,0 +1,38 @@
+package org.jabref.logic.importer;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import org.jabref.logic.importer.fetcher.AdvancedSearchConfig;
+import org.jabref.logic.net.URLDownload;
+import org.jabref.model.entry.BibEntry;
+
+/**
+ * This interface allows SearchBasedParserFetcher fetchers to test their corresponding
+ * library APIs for their advanced search options, e.g. search in the "title" field.
+ */
+public interface AdvancedFetcher extends SearchBasedParserFetcher {
+
+    /**
+     * This method is used to send queries with advanced URL parameters.
+     * This method is necessary as the performSearch method does not support certain URL parameters that are used for
+     * fielded search, such as a title, author, or year parameter.
+     *
+     * @param advancedSearchConfig the search config defining all fielded search parameters
+     */
+    default List<BibEntry> performAdvancedSearch(AdvancedSearchConfig advancedSearchConfig) throws FetcherException {
+        try (InputStream stream = getAdvancedURLDownload(advancedSearchConfig).asInputStream()) {
+            List<BibEntry> fetchedEntries = getParser().parseEntries(stream);
+            fetchedEntries.forEach(this::doPostCleanup);
+            return fetchedEntries;
+        } catch (IOException e) {
+            // TODO: Catch HTTP Response 401/403 errors and report that user has no rights to access resource
+            throw new FetcherException("A network error occurred", e);
+        } catch (ParseException e) {
+            throw new FetcherException("An internal parser error occurred", e);
+        }
+    }
+
+    URLDownload getAdvancedURLDownload(AdvancedSearchConfig advancedSearchConfig);
+}

src/main/java/org/jabref/logic/importer/fetcher/AdvancedSearchConfig.java

@@ -0,0 +1,125 @@
+package org.jabref.logic.importer.fetcher;
+
+import java.util.Objects;
+import java.util.Optional;
+
+import org.jabref.model.strings.StringUtil;
+
+public class AdvancedSearchConfig {
+    private final String defaultField;
+    private final String author;
+    private final String title;
+    private final Integer fromYear;
+    private final Integer toYear;
+    private final String journal;
+
+    private AdvancedSearchConfig(String defaultField, String author, String title, Integer fromYear, Integer toYear, String journal) {
+        this.defaultField = defaultField;
+        this.author = author;
+        this.title = title;
+        this.fromYear = fromYear;
+        this.toYear = toYear;
+        this.journal = journal;
+    }
+
+    public Optional<String> getDefaultField() {
+        return Optional.ofNullable(defaultField);
+    }
+
+    public Optional<String> getAuthor() {
+        return Optional.ofNullable(author);
+    }
+
+    public Optional<String> getTitle() {
+        return Optional.ofNullable(title);
+    }
+
+    public Optional<Integer> getFromYear() {
+        return Optional.ofNullable(fromYear);
+    }
+
+    public Optional<Integer> getToYear() {
+        return Optional.ofNullable(toYear);
+    }
+
+    public Optional<String> getJournal() {
+        return Optional.ofNullable(journal);
+    }
+
+    public static AdvancedSearchConfigBuilder builder() {
+        return new AdvancedSearchConfigBuilder();
+    }
+
+    public static class AdvancedSearchConfigBuilder {
+        private String defaultField;
+        private String author;
+        private String title;
+        private String journal;
+        private Integer fromYear;
+        private Integer toYear;
+
+        public AdvancedSearchConfigBuilder() {
+        }
+
+        public AdvancedSearchConfigBuilder defaultField(String defaultField) {
+            if (Objects.requireNonNull(defaultField).isBlank()) {
+                throw new IllegalArgumentException("Parameter must not be blank");
+            }
+            this.defaultField = defaultField;
+            return this;
+        }
+
+        public AdvancedSearchConfigBuilder author(String author) {
+            if (Objects.requireNonNull(author).isBlank()) {
+                throw new IllegalArgumentException("Parameter must not be blank");
+            }
+            this.author = author;
+            return this;
+        }
+
+        public AdvancedSearchConfigBuilder title(String title) {
+            if (Objects.requireNonNull(title).isBlank()) {
+                throw new IllegalArgumentException("Parameter must not be blank");
+            }
+            this.title = title;
+            return this;
+        }
+
+        public AdvancedSearchConfigBuilder fromYear(Integer fromYear) {
+            this.fromYear = Objects.requireNonNull(fromYear);
+            return this;
+        }
+
+        public AdvancedSearchConfigBuilder toYear(Integer toYear) {
+            this.toYear = Objects.requireNonNull(toYear);
+            return this;
+        }
+
+        public AdvancedSearchConfigBuilder journal(String journal) {
+            if (Objects.requireNonNull(journal).isBlank()) {
+                throw new IllegalArgumentException("Parameter must not be blank");
+            }
+            this.journal = journal;
+            return this;
+        }
+
+        /**
+         * Instantiates the AdvancesSearchConfig from the provided Builder parameters
+         * If all text fields are empty an empty optional is returned
+         *
+         * @return AdvancedSearchConfig instance with the fields set to the values defined in the building instance.
+         * @throws IllegalStateException An IllegalStateException is thrown in case all text search fields are empty.
+         *                               See: https://softwareengineering.stackexchange.com/questions/241309/builder-pattern-when-to-fail/241320#241320
+         */
+        public AdvancedSearchConfig build() throws IllegalStateException {
+            if (textSearchFieldsAreEmpty()) {
+                throw new IllegalStateException("At least one text field has to be set");
+            }
+            return new AdvancedSearchConfig(defaultField, author, title, fromYear, toYear, journal);
+        }
+
+        private boolean textSearchFieldsAreEmpty() {
+            return StringUtil.isBlank(defaultField) && StringUtil.isBlank(title) && StringUtil.isBlank(author) && StringUtil.isBlank(journal);
+        }
+    }
+}

src/main/java/org/jabref/logic/importer/fetcher/ArXiv.java

@@ -158,7 +158,7 @@ private List<ArXivEntry> searchForEntries(String searchQuery) throws FetcherExce
     }
 
     private List<ArXivEntry> queryApi(String searchQuery, List<ArXivIdentifier> ids, int start, int maxResults)
-        throws FetcherException {
+            throws FetcherException {
         Document result = callApi(searchQuery, ids, start, maxResults);
         List<Node> entries = XMLUtil.asList(result.getElementsByTagName("entry"));
 

src/main/java/org/jabref/logic/importer/fetcher/IEEE.java

@@ -16,6 +16,7 @@
 import java.util.stream.Collectors;
 
 import org.jabref.logic.help.HelpFile;
+import org.jabref.logic.importer.AdvancedFetcher;
 import org.jabref.logic.importer.FulltextFetcher;
 import org.jabref.logic.importer.ImportFormatPreferences;
 import org.jabref.logic.importer.Parser;
@@ -42,7 +43,7 @@
  *
  * @implNote <a href="https://developer.ieee.org/docs">API documentation</a>
  */
-public class IEEE implements FulltextFetcher, SearchBasedParserFetcher {
+public class IEEE implements FulltextFetcher, SearchBasedParserFetcher, AdvancedFetcher {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(IEEE.class);
     private static final String STAMP_BASE_STRING_DOCUMENT = "/stamp/stamp.jsp?tp=&arnumber=";
@@ -67,18 +68,10 @@ private static BibEntry parseJsonRespone(JSONObject jsonEntry, Character keyword
         BibEntry entry = new BibEntry();
 
         switch (jsonEntry.optString("content_type")) {
-            case "Books":
-                entry.setType(StandardEntryType.Book);
-                break;
-            case "Conferences":
-                entry.setType(StandardEntryType.InProceedings);
-                break;
-            case "Courses":
-                entry.setType(StandardEntryType.Misc);
-                break;
-            default:
-                entry.setType(StandardEntryType.Article);
-                break;
+            case "Books" -> entry.setType(StandardEntryType.Book);
+            case "Conferences" -> entry.setType(StandardEntryType.InProceedings);
+            case "Courses" -> entry.setType(StandardEntryType.Misc);
+            default -> entry.setType(StandardEntryType.Article);
         }
 
         entry.setField(StandardField.ABSTRACT, jsonEntry.optString("abstract"));
@@ -236,4 +229,26 @@ public String getName() {
     public Optional<HelpFile> getHelpPage() {
         return Optional.of(HelpFile.FETCHER_IEEEXPLORE);
     }
+
+    @Override
+    public URLDownload getAdvancedURLDownload(AdvancedSearchConfig advancedSearchConfig) {
+        URLDownload urlDownload;
+        try {
+            URIBuilder uriBuilder = new URIBuilder("https://ieeexploreapi.ieee.org/api/v1/search/articles");
+            uriBuilder.addParameter("apikey", API_KEY);
+            advancedSearchConfig.getDefaultField().ifPresent(defaultField -> uriBuilder.addParameter("querytext", defaultField));
+            advancedSearchConfig.getAuthor().ifPresent(author -> uriBuilder.addParameter("author", author));
+            advancedSearchConfig.getTitle().ifPresent(articleTitle -> uriBuilder.addParameter("article_title", articleTitle));
+            advancedSearchConfig.getJournal().ifPresent(journalTitle -> uriBuilder.addParameter("publication_title", journalTitle));
+            advancedSearchConfig.getFromYear().map(String::valueOf).ifPresent(year -> uriBuilder.addParameter("start_year", year));
+            advancedSearchConfig.getToYear().map(String::valueOf).ifPresent(year -> uriBuilder.addParameter("end_year", year));
+
+            URLDownload.bypassSSLVerification();
+            urlDownload = new URLDownload(uriBuilder.build().toURL());
+        } catch (URISyntaxException | MalformedURLException ex) {
+            LOGGER.error("Error creating URL.", ex);
+            throw new IllegalStateException("Error during creation of URL.", ex);
+        }
+        return urlDownload;
+    }
 }