refactor(SeriesInfoExtractorServiceImplTest): make extractReleaseYear() more generic and rename it.

Part of #1287

Author: php-coder

src/main/java/ru/mystamps/web/feature/series/importing/SeriesInfoExtractorServiceImpl.java

@@ -36,6 +36,7 @@
 import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -47,12 +48,13 @@
 @SuppressWarnings({ "PMD.TooManyMethods", "PMD.GodClass" })
 public class SeriesInfoExtractorServiceImpl implements SeriesInfoExtractorService {
 
-	// Related to RELEASE_YEAR_REGEXP and used in unit tests.
+	// Related to RELEASE_DATE_REGEXP and used in unit tests.
 	protected static final int MAX_SUPPORTED_RELEASE_YEAR = 2099;
 
-	// Regular expression matches release year of the stamps (from 1840 till 2099).
+	// Regular expression matches release date of the stamps.
+	// Year should be in range within 1840 and 2099 inclusive.
 	// CheckStyle: ignore LineLength for next 2 lines
-	private static final Pattern RELEASE_YEAR_REGEXP =
+	private static final Pattern RELEASE_DATE_REGEXP =
 		Pattern.compile("([0-9]{2}\\.[0-9]{2}\\.)?(?<year>18[4-9][0-9]|19[0-9]{2}|20[0-9]{2})(г(од|\\.)?)?");
 
 	// Regular expression matches number of the stamps in a series (from 1 to 999).
@@ -101,7 +103,7 @@ public class SeriesInfoExtractorServiceImpl implements SeriesInfoExtractorServic
 	public SeriesExtractedInfo extract(String pageUrl, RawParsedDataDto data) {
 		List<Integer> categoryIds = extractCategory(data.getCategoryName());
 		List<Integer> countryIds = extractCountry(data.getCountryName());
-		Integer releaseYear = extractReleaseYear(data.getIssueDate());
+		Map<String, Integer> releaseDate = extractIssueDate(data.getIssueDate());
 		Integer quantity = extractQuantity(data.getQuantity());
 		Boolean perforated = extractPerforated(data.getPerforated());
 		Set<String> michelNumbers = extractMichelNumbers(data.getMichelNumbers());
@@ -117,7 +119,7 @@ public SeriesExtractedInfo extract(String pageUrl, RawParsedDataDto data) {
 		return new SeriesExtractedInfo(
 			categoryIds,
 			countryIds,
-			releaseYear,
+			releaseDate.get("year"),
 			quantity,
 			perforated,
 			michelNumbers,
@@ -214,33 +216,33 @@ public SeriesExtractedInfo extract(String pageUrl, RawParsedDataDto data) {
 		return Collections.emptyList();
 	}
 
-	/* default */ Integer extractReleaseYear(String fragment) {
+	/* default */ Map<String, Integer> extractIssueDate(String fragment) {
 		if (StringUtils.isBlank(fragment)) {
-			return null;
+			return Collections.emptyMap();
 		}
 
-		log.debug("Determine release year from '{}'", fragment);
+		log.debug("Determine release date from '{}'", fragment);
 
 		String[] candidates = StringUtils.split(fragment, " \t,");
 		for (String candidate : candidates) {
-			Matcher matcher = RELEASE_YEAR_REGEXP.matcher(candidate);
+			Matcher matcher = RELEASE_DATE_REGEXP.matcher(candidate);
 			if (!matcher.matches()) {
 				continue;
 			}
 
 			try {
 				Integer year = Integer.valueOf(matcher.group("year"));
 				log.debug("Release year is {}", year);
-				return year;
+				return Collections.singletonMap("year", year);
 
 			} catch (NumberFormatException ignored) { // NOPMD: EmptyCatchBlock
 				// continue with the next element
 			}
 		}
 
-		log.debug("Could not extract release year from a fragment");
+		log.debug("Could not extract release date from a fragment");
 
-		return null;
+		return Collections.emptyMap();
 	}
 
 	/* default */ Integer extractQuantity(String fragment) {

src/test/groovy/ru/mystamps/web/feature/series/importing/SeriesInfoExtractorServiceImplTest.groovy

@@ -230,59 +230,59 @@ class SeriesInfoExtractorServiceImplTest extends Specification {
 	}
 
 	//
-	// Tests for extractReleaseYear()
+	// Tests for extractIssueDate()
 	//
 
-	def 'extractReleaseYear() should return null when fragment is null, empty or blank'() {
+	def 'extractIssueDate() should return empty map when fragment is null, empty or blank'() {
 		given:
 			String fragment = nullOrBlank()
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == null
+			date.isEmpty()
 	}
 
-	def 'extractReleaseYear() should extract year from XIX century'() {
+	def 'extractIssueDate() should extract year from XIX century'() {
 		given:
 			Integer expectedYear = between(SeriesValidation.MIN_RELEASE_YEAR, 1899).integer()
 		and:
 			String fragment = String.valueOf(expectedYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == expectedYear
+			date.get('year') == expectedYear
 	}
 
-	def 'extractReleaseYear() should extract year from XX century'() {
+	def 'extractIssueDate() should extract year from XX century'() {
 		given:
 			Integer expectedYear = between(1900, 1999).integer()
 		and:
 			String fragment = String.valueOf(expectedYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == expectedYear
+			date.get('year') == expectedYear
 	}
 
-	def 'extractReleaseYear() should extract year from XXI century'() {
+	def 'extractIssueDate() should extract year from XXI century'() {
 		given:
 			Integer expectedYear = between(2000, MAX_SUPPORTED_RELEASE_YEAR).integer()
 		and:
 			String fragment = String.valueOf(expectedYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == expectedYear
+			date.get('year') == expectedYear
 	}
 
 	@Unroll
-	def 'extractReleaseYear() should extract date from "#fragment"'(String fragment) {
+	def 'extractIssueDate() should extract date from "#fragment"'(String fragment) {
 		given:
 			Integer expectedYear = 2010 // should be in sync with examples below
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == expectedYear
+			date.get('year') == expectedYear
 		where:
 			fragment                         | _
 			'italy 2010'                     | _
@@ -299,7 +299,7 @@ class SeriesInfoExtractorServiceImplTest extends Specification {
 	}
 
 	@SuppressWarnings('UnnecessaryGetter')
-	def 'extractReleaseYear() should return the first year if there are many'() {
+	def 'extractIssueDate() should return the first year if there are many'() {
 		given:
 			Integer currentYear = Year.now().getValue()
 			Integer expectedYear = between(SeriesValidation.MIN_RELEASE_YEAR, currentYear).integer()
@@ -308,13 +308,13 @@ class SeriesInfoExtractorServiceImplTest extends Specification {
 		and:
 			String fragment = String.format('%d %d', expectedYear, anotherYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == expectedYear
+			date.get('year') == expectedYear
 	}
 
 	@SuppressWarnings('UnnecessaryGetter')
-	def 'extractReleaseYear() should skip invalid date'() {
+	def 'extractIssueDate() should skip invalid date'() {
 		given:
 			Integer unsupportedYearInPast = between(0, SeriesValidation.MIN_RELEASE_YEAR - 1).integer()
 			Integer unsupportedYearInFuture = between(MAX_SUPPORTED_RELEASE_YEAR + 1, Integer.MAX_VALUE).integer()
@@ -325,37 +325,37 @@ class SeriesInfoExtractorServiceImplTest extends Specification {
 		and:
 			String fragment = String.format('%d %d', unsupportedYear, expectedYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == expectedYear
+			date.get('year') == expectedYear
 	}
 
-	def 'extractReleaseYear() shouldn\'t extract dates before 1840'() {
+	def 'extractIssueDate() shouldn\'t extract dates before 1840'() {
 		given:
 			Integer unsupportedYear = between(0, SeriesValidation.MIN_RELEASE_YEAR - 1).integer()
 			String fragment = String.valueOf(unsupportedYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == null
+			date.isEmpty()
 	}
 
-	def 'extractReleaseYear() shouldn\'t extract dates after 2099'() {
+	def 'extractIssueDate() shouldn\'t extract dates after 2099'() {
 		given:
 			Integer unsupportedYear = between(MAX_SUPPORTED_RELEASE_YEAR + 1, Integer.MAX_VALUE).integer()
 			String fragment = String.valueOf(unsupportedYear)
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == null
+			date.isEmpty()
 	}
 
 	@Unroll
-	def 'extractReleaseYear() shouldn\'t extract date from "#fragment"'(String fragment) {
+	def 'extractIssueDate() shouldn\'t extract date from "#fragment"'(String fragment) {
 		when:
-			Integer year = service.extractReleaseYear(fragment)
+			Map<String, Integer> date = service.extractIssueDate(fragment)
 		then:
-			year == null
+			date.isEmpty()
 		where:
 			fragment           | _
 			'-2000'            | _