From 58ca5b1c4b96dcabc671013de5bd39f96bb8f75e Mon Sep 17 00:00:00 2001 From: aitestmate Date: Fri, 22 May 2026 08:27:40 +0000 Subject: [PATCH 1/2] [chore] [mod-data-export] unit tests --- .../export/strategies/RuleFactoryTest.java | 133 ++++++++++++++++++ 1 file changed, 133 insertions(+) diff --git a/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java b/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java index 1c35cfa16..c0f1e42aa 100644 --- a/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java +++ b/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java @@ -26,6 +26,13 @@ import org.junit.jupiter.params.provider.CsvSource; import org.mockito.InjectMocks; import org.mockito.junit.jupiter.MockitoExtension; +import static org.mockito.Mockito.verify; +import java.util.Collections; +import java.util.Set; +import static org.folio.dataexp.service.export.Constants.DEFAULT_INSTANCE_MAPPING_PROFILE_ID; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doThrow; @ExtendWith(MockitoExtension.class) class RuleFactoryTest { @@ -392,4 +399,130 @@ void buildRulesShouldCallCreateWhenRulesFromConfigIsEmpty() throws Transformatio .containsExactly(instanceDefaultRule) .doesNotContain(holdingsDefaultRule); } + + @Test + void createShouldAppendHoldingsDefaultRulesWhenRequested() throws TransformationRuleException { + // TestMate-2dc55c8cc79b1f8dfcde3801e9b672a5 + // Given + var initialRule = new Rule(); + initialRule.setId("instance.hrid"); + var initialRules = new ArrayList<>(List.of(initialRule)); + var defaultHoldingsRule = new Rule(); + defaultHoldingsRule.setId("holdings.default"); + var defaultHoldingsRules = List.of(defaultHoldingsRule); + var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), defaultHoldingsRules); + var mappingProfile = new MappingProfile(); + mappingProfile.setId(UUID.fromString("c0a80101-0000-0000-0000-000000000001")); + mappingProfile.setRecordTypes(List.of(RecordTypes.HOLDINGS)); + mappingProfile.setTransformations(new ArrayList<>()); + // When + var actualRules = ruleFactoryLocal.create(mappingProfile, initialRules, true); + // Then + assertThat(actualRules) + .isSameAs(initialRules) + .hasSize(2) + .containsExactly(initialRule, defaultHoldingsRule); + } + + @Test + void createShouldGenerateRulesFromTransformations() throws TransformationRuleException { + // TestMate-b230324ed45cb21c127310ac69ed7026 + // Given + var customProfileId = UUID.fromString("d0a80101-0000-0000-0000-000000000001"); + var mappingProfile = new MappingProfile(); + mappingProfile.setId(customProfileId); + var transformation = new Transformations(); + transformation.setFieldId("instance.title"); + var transformations = List.of(transformation); + mappingProfile.setTransformations(transformations); + mappingProfile.setRecordTypes(Collections.emptyList()); + var initialDefaultRules = new ArrayList(); + var expectedRule = new Rule(); + expectedRule.setId("transformed.rule"); + var expectedRulesSet = Set.of(expectedRule); + var spyRuleFactory = spy(ruleFactory); + doReturn(expectedRulesSet).when(spyRuleFactory).createByTransformations(transformations, initialDefaultRules); + // When + var actualRules = spyRuleFactory.create(mappingProfile, initialDefaultRules, false); + // Then + assertThat(actualRules) + .hasSize(1) + .containsExactly(expectedRule); + verify(spyRuleFactory).createByTransformations(transformations, initialDefaultRules); + } + + @Test + void createShouldAppendDefaultInstanceRulesForDefaultProfile() throws TransformationRuleException { + // TestMate-56278d4dda4f2cbc4d2effc83b633b69 + // Given + var baselineRule = new Rule(); + baselineRule.setId("baseline.rule"); + var defaultRulesFromConfigFile = List.of(baselineRule); + var ruleFactoryLocal = new RuleFactory(defaultRulesFromConfigFile, new ArrayList<>()); + var spyRuleFactory = spy(ruleFactoryLocal); + var mappingProfile = new MappingProfile(); + mappingProfile.setId(UUID.fromString(DEFAULT_INSTANCE_MAPPING_PROFILE_ID)); + var transformations = List.of(new Transformations()); + mappingProfile.setTransformations(transformations); + var customRule = new Rule(); + customRule.setId("custom.rule"); + var customRulesSet = Set.of(customRule); + // Fix: Use eq() matcher for the first argument because anyList() is used for the second argument + doReturn(customRulesSet) + .when(spyRuleFactory) + .createByTransformations(eq(transformations), anyList()); + // When + var actualRules = spyRuleFactory.create(mappingProfile, new ArrayList<>(), false); + // Then + assertThat(actualRules).hasSize(2).containsExactly(customRule, baselineRule); + verify(spyRuleFactory).createByTransformations(eq(transformations), anyList()); + } + + @Test + void createShouldNotAppendHoldingsRulesWhenRequestedButTypeNotHoldings() throws TransformationRuleException { + // TestMate-4f84bc23a2303857eb884a745670ae71 + // Given + var initialRule = new Rule(); + initialRule.setId("instance.hrid"); + var initialRules = new ArrayList<>(List.of(initialRule)); + var defaultHoldingsRule = new Rule(); + defaultHoldingsRule.setId("holdings.default"); + var defaultHoldingsRules = List.of(defaultHoldingsRule); + var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), defaultHoldingsRules); + var mappingProfile = new MappingProfile(); + mappingProfile.setId(UUID.fromString("d0a80101-0000-0000-0000-000000000001")); + mappingProfile.setRecordTypes(List.of(RecordTypes.INSTANCE)); + mappingProfile.setTransformations(null); + // When + var actualRules = ruleFactoryLocal.create(mappingProfile, initialRules, true); + // Then + assertThat(actualRules) + .isSameAs(initialRules) + .hasSize(1) + .containsExactly(initialRule) + .doesNotContain(defaultHoldingsRule); + } + + @Test + void createShouldPropagateTransformationRuleExceptionFromCreateByTransformations() throws TransformationRuleException { + // TestMate-25f02f01c02973ad5f8aa00674140688 + // Given + var mappingProfile = new MappingProfile(); + mappingProfile.setId(UUID.fromString("c0a80101-0000-0000-0000-000000000001")); + mappingProfile.setRecordTypes(List.of(RecordTypes.INSTANCE)); + var transformations = List.of(new Transformations()); + mappingProfile.setTransformations(transformations); + var defaultRules = new ArrayList(); + var exceptionMessage = "Transformation failed"; + var spyRuleFactory = spy(ruleFactory); + doThrow(new TransformationRuleException(exceptionMessage)) + .when(spyRuleFactory) + .createByTransformations(anyList(), anyList()); + // When + var exception = assertThrows(TransformationRuleException.class, () -> + spyRuleFactory.create(mappingProfile, defaultRules, false)); + // Then + assertThat(exception.getMessage()).isEqualTo(exceptionMessage); + verify(spyRuleFactory).createByTransformations(transformations, defaultRules); + } } From 5788055ca3079bdc51279d9d4a600677e98e2617 Mon Sep 17 00:00:00 2001 From: Viachaslau Khandramai Date: Fri, 22 May 2026 11:06:35 +0200 Subject: [PATCH 2/2] Reformatting code, refactoring --- .../export/LocalStorageWriterTest.java | 5 +- .../export/strategies/RuleFactoryTest.java | 525 +++++++++--------- 2 files changed, 256 insertions(+), 274 deletions(-) diff --git a/src/test/java/org/folio/dataexp/service/export/LocalStorageWriterTest.java b/src/test/java/org/folio/dataexp/service/export/LocalStorageWriterTest.java index a342e9dc9..f390d994e 100644 --- a/src/test/java/org/folio/dataexp/service/export/LocalStorageWriterTest.java +++ b/src/test/java/org/folio/dataexp/service/export/LocalStorageWriterTest.java @@ -73,8 +73,9 @@ void closeShouldCloseWriterWhenFileExists() { var localStorageWriter = spy(createWriter(fileName)); localStorageWriter.write("test data"); var bufferedWriterSpy = - spy((BufferedWriter) Objects.requireNonNull( - ReflectionTestUtils.getField(localStorageWriter, "writer"))); + spy( + (BufferedWriter) + Objects.requireNonNull(ReflectionTestUtils.getField(localStorageWriter, "writer"))); ReflectionTestUtils.setField(localStorageWriter, "writer", bufferedWriterSpy); var filePath = resolveFile(fileName); diff --git a/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java b/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java index c0f1e42aa..50b82d614 100644 --- a/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java +++ b/src/test/java/org/folio/dataexp/service/export/strategies/RuleFactoryTest.java @@ -1,16 +1,22 @@ package org.folio.dataexp.service.export.strategies; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.folio.dataexp.service.export.Constants.DEFAULT_INSTANCE_MAPPING_PROFILE_ID; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.Set; import java.util.UUID; import org.folio.dataexp.TestMate; import org.folio.dataexp.domain.dto.MappingProfile; @@ -26,31 +32,76 @@ import org.junit.jupiter.params.provider.CsvSource; import org.mockito.InjectMocks; import org.mockito.junit.jupiter.MockitoExtension; -import static org.mockito.Mockito.verify; -import java.util.Collections; -import java.util.Set; -import static org.folio.dataexp.service.export.Constants.DEFAULT_INSTANCE_MAPPING_PROFILE_ID; -import static org.mockito.ArgumentMatchers.anyList; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.doThrow; @ExtendWith(MockitoExtension.class) class RuleFactoryTest { @InjectMocks private RuleFactory ruleFactory; + // ===== Helper methods ===== + + private static Transformations createTransformations( + boolean enabled, String fieldId, RecordTypes recordType) { + var t = new Transformations(); + t.setEnabled(enabled); + t.setFieldId(fieldId); + t.setRecordType(recordType); + return t; + } + + private static Rule createRule(String id, String field) { + var rule = new Rule(); + rule.setId(id); + rule.setField(field); + return rule; + } + + private static DataSource createDataSource(String indicator, String translationValue) { + var ds = new DataSource(); + ds.setIndicator(indicator); + if (translationValue != null) { + ds.setTranslation(createTranslation(translationValue)); + } + return ds; + } + + private static Translation createTranslation(String value) { + var translation = new Translation(); + translation.setParameters(Map.of("value", value)); + return translation; + } + + private static Rule create999ffRule() { + var rule = new Rule(); + rule.setField("999"); + rule.setDataSources(List.of(createDataSource("1", "f"), createDataSource("2", "f"))); + return rule; + } + + private static MappingProfile createMappingProfile( + UUID id, boolean suppress999ff, String fieldsSuppression, List recordTypes) { + var profile = new MappingProfile(); + profile.setId(id); + profile.setSuppress999ff(suppress999ff); + profile.setFieldsSuppression(fieldsSuppression); + if (recordTypes != null) { + profile.setRecordTypes(recordTypes); + } + return profile; + } + + // ===== Tests ===== + @Test @TestMate(name = "TestMate-d999471200a03a6a5b0d63efe04dbe53") void shouldReturnEmpty_whenRecordTypeIsNotInstance() throws TransformationRuleException { // Given - Transformations transformations = new Transformations(); - transformations.setEnabled(true); - transformations.setFieldId("holdings.hrid"); - transformations.setRecordType(RecordTypes.HOLDINGS); - List defaultRules = new ArrayList<>(); + var transformations = createTransformations(true, "holdings.hrid", RecordTypes.HOLDINGS); + // When Optional result = - ruleFactory.createDefaultByTransformations(transformations, defaultRules); + ruleFactory.createDefaultByTransformations(transformations, new ArrayList<>()); + // Then assertThat(result).isEmpty(); } @@ -59,29 +110,19 @@ void shouldReturnEmpty_whenRecordTypeIsNotInstance() throws TransformationRuleEx @TestMate(name = "TestMate-3dcc1f62c61e104028cf0b12117a1d11") void testCreateDefaultByTransformationsShouldPropagateTransformationRuleException() { // Given - // We use a fieldId that contains "transformation.builder" to trigger the - // TransformationRuleBuilder - // which is already instantiated in the static map of the RuleFactory. - Transformations transformations = new Transformations(); - transformations.setEnabled(true); - transformations.setFieldId("transformation.builder.test"); - transformations.setTransformation("900 $a"); // Valid transformation format - transformations.setRecordType(RecordTypes.INSTANCE); - - // TransformationRuleBuilder.build iterates over the provided rules. - // According to Reference 5, it throws TransformationRuleException if an existing rule - // for the same field has null indicators. - List defaultRules = new ArrayList<>(); - Rule existingRule = new Rule(); + var transformations = + createTransformations(true, "transformation.builder.test", RecordTypes.INSTANCE); + transformations.setTransformation("900 $a"); + + var existingRule = new Rule(); existingRule.setField("900"); - existingRule.setIndicators(null); // This triggers the exception in TransformationRuleBuilder - defaultRules.add(existingRule); + existingRule.setIndicators(null); + var defaultRules = new ArrayList<>(List.of(existingRule)); + // When & Then - // The method should delegate to TransformationRuleBuilder, which throws the exception, - // and RuleFactory should propagate it. - assertThrows( - TransformationRuleException.class, - () -> ruleFactory.createDefaultByTransformations(transformations, defaultRules)); + assertThatThrownBy( + () -> ruleFactory.createDefaultByTransformations(transformations, defaultRules)) + .isInstanceOf(TransformationRuleException.class); } @ParameterizedTest @@ -90,14 +131,12 @@ void testCreateDefaultByTransformationsShouldPropagateTransformationRuleExceptio void createDefaultByTransformations_shouldReturnEmpty_whenDisabledOrFieldIdBlank( boolean enabled, String fieldId) throws TransformationRuleException { // Given - Transformations transformations = new Transformations(); - transformations.setEnabled(enabled); - transformations.setFieldId(fieldId); - transformations.setRecordType(RecordTypes.INSTANCE); - List defaultRules = new ArrayList<>(); + var transformations = createTransformations(enabled, fieldId, RecordTypes.INSTANCE); + // When Optional result = - ruleFactory.createDefaultByTransformations(transformations, defaultRules); + ruleFactory.createDefaultByTransformations(transformations, new ArrayList<>()); + // Then assertThat(result).isEmpty(); } @@ -106,103 +145,72 @@ void createDefaultByTransformations_shouldReturnEmpty_whenDisabledOrFieldIdBlank @TestMate(name = "TestMate-8731170170f755ee33961c2944bda653") void createDefaultByTransformations_shouldUseSpecificBuilder_whenFieldIdMatchesKey() throws TransformationRuleException { - // Given - var transformationFieldId = "instance.electronic.access.uri"; - var transformationPath = "$.source.uri"; - Transformations transformations = new Transformations(); - transformations.setEnabled(true); - transformations.setFieldId(transformationFieldId); - transformations.setPath(transformationPath); - transformations.setRecordType(RecordTypes.INSTANCE); - - var defaultRuleMarcField = "856"; - Rule defaultRule = new Rule(); - defaultRule.setId("instance.electronic.access"); - defaultRule.setField(defaultRuleMarcField); - - var expectedSubfield = "u"; - DataSource matchingDataSource = new DataSource(); + var transformations = + createTransformations(true, "instance.electronic.access.uri", RecordTypes.INSTANCE); + transformations.setPath("$.source.uri"); + + var matchingDataSource = new DataSource(); matchingDataSource.setFrom("$.instance.electronicAccess[*].uri"); - matchingDataSource.setSubfield(expectedSubfield); + matchingDataSource.setSubfield("u"); + + var defaultRule = createRule("instance.electronic.access", "856"); defaultRule.setDataSources(new ArrayList<>(List.of(matchingDataSource))); - List defaultRules = new ArrayList<>(List.of(defaultRule)); + // When Optional result = - ruleFactory.createDefaultByTransformations(transformations, defaultRules); + ruleFactory.createDefaultByTransformations( + transformations, new ArrayList<>(List.of(defaultRule))); + // Then - assertTrue(result.isPresent()); - Rule actualRule = result.get(); - assertThat(actualRule.getField()).isEqualTo(defaultRuleMarcField); + assertThat(result).isPresent(); + var actualRule = result.get(); + assertThat(actualRule.getField()).isEqualTo("856"); - DataSource actualDataSource = + var actualDataSource = actualRule.getDataSources().stream() .filter(ds -> ds.getIndicator() == null) .findFirst() .orElseThrow(); - - assertThat(actualDataSource.getFrom()).isEqualTo(transformationPath); - assertThat(actualDataSource.getSubfield()).isEqualTo(expectedSubfield); + assertThat(actualDataSource.getFrom()).isEqualTo("$.source.uri"); + assertThat(actualDataSource.getSubfield()).isEqualTo("u"); } @Test @TestMate(name = "TestMate-4959e1b60d69a04af56ac35d2a056652") void createDefaultByTransformations_shouldFallbackToDefaultBuilder_whenNoSpecificKeyMatches() throws TransformationRuleException { - // Given - var fieldId = "instance.title"; - Transformations transformations = new Transformations(); - transformations.setEnabled(true); - transformations.setFieldId(fieldId); - transformations.setRecordType(RecordTypes.INSTANCE); - var marcField = "245"; - Rule titleRule = new Rule(); - titleRule.setId(fieldId); - titleRule.setField(marcField); - List defaultRules = new ArrayList<>(List.of(titleRule)); + var transformations = createTransformations(true, "instance.title", RecordTypes.INSTANCE); + var titleRule = createRule("instance.title", "245"); + // When Optional result = - ruleFactory.createDefaultByTransformations(transformations, defaultRules); + ruleFactory.createDefaultByTransformations( + transformations, new ArrayList<>(List.of(titleRule))); + // Then - assertTrue(result.isPresent()); - Rule actualRule = result.get(); - assertThat(actualRule.getId()).isEqualTo(fieldId); - assertThat(actualRule.getField()).isEqualTo(marcField); + assertThat(result) + .isPresent() + .get() + .satisfies( + rule -> { + assertThat(rule.getId()).isEqualTo("instance.title"); + assertThat(rule.getField()).isEqualTo("245"); + }); } @Test @TestMate(name = "TestMate-7e6135e04aa1ae0d5457e4de2d286332") void getRulesShouldReturnAllRulesWhenNoSuppressionIsActive() throws TransformationRuleException { // Given - var mappingProfile = new MappingProfile(); - mappingProfile.setSuppress999ff(false); - mappingProfile.setFieldsSuppression(null); - - var rule001 = new Rule(); - rule001.setField("001"); - var rule999ff = new Rule(); - rule999ff.setField("999"); - - var translationF = new Translation(); - translationF.setParameters(Map.of("value", "f")); - - var ds1 = new DataSource(); - ds1.setIndicator("1"); - ds1.setTranslation(translationF); - - var ds2 = new DataSource(); - ds2.setIndicator("2"); - ds2.setTranslation(translationF); - - rule999ff.setDataSources(List.of(ds1, ds2)); - var rule100 = new Rule(); - rule100.setField("100"); - + var mappingProfile = createMappingProfile(null, false, null, null); + var rule001 = createRule(null, "001"); + var rule999ff = create999ffRule(); + var rule100 = createRule(null, "100"); var expectedRules = List.of(rule001, rule999ff, rule100); - // Create a spy of the injected ruleFactory to allow partial mocking of buildRules - var spyRuleFactory = org.mockito.Mockito.spy(ruleFactory); + var spyRuleFactory = spy(ruleFactory); doReturn(expectedRules).when(spyRuleFactory).buildRules(any(MappingProfile.class)); // When @@ -216,42 +224,26 @@ void getRulesShouldReturnAllRulesWhenNoSuppressionIsActive() throws Transformati @TestMate(name = "TestMate-b94b4a5ac8d1a9ce863cfd71b32fae81") void getRulesShouldFilter999ffWhenSuppress999ffIsTrue() throws TransformationRuleException { // Given - var mappingProfile = new MappingProfile(); - mappingProfile.setSuppress999ff(true); - mappingProfile.setFieldsSuppression(null); - var translationF = new Translation(); - translationF.setParameters(Map.of("value", "f")); - var ds1 = new DataSource(); - ds1.setIndicator("1"); - ds1.setTranslation(translationF); - var ds2 = new DataSource(); - ds2.setIndicator("2"); - ds2.setTranslation(translationF); - var rule999ff = new Rule(); - rule999ff.setField("999"); - rule999ff.setDataSources(List.of(ds1, ds2)); - var translationA = new Translation(); - translationA.setParameters(Map.of("value", "a")); - var translationB = new Translation(); - translationB.setParameters(Map.of("value", "b")); - var ds3 = new DataSource(); - ds3.setIndicator("1"); - ds3.setTranslation(translationA); - var ds4 = new DataSource(); - ds4.setIndicator("2"); - ds4.setTranslation(translationB); - var rule999ab = new Rule(); - rule999ab.setField("999"); - rule999ab.setDataSources(List.of(ds3, ds4)); var rule001 = new Rule(); rule001.setField("001"); rule001.setDataSources(new ArrayList<>()); - var initialRules = List.of(rule999ff, rule999ab, rule001); - // Create a spy of the ruleFactory to allow partial mocking of the buildRules method - var spyRuleFactory = org.mockito.Mockito.spy(ruleFactory); - doReturn(initialRules).when(spyRuleFactory).buildRules(any(MappingProfile.class)); + + var rule999ff = create999ffRule(); + + var rule999ab = new Rule(); + rule999ab.setField("999"); + rule999ab.setDataSources(List.of(createDataSource("1", "a"), createDataSource("2", "b"))); + + var spyRuleFactory = spy(ruleFactory); + doReturn(List.of(rule999ff, rule999ab, rule001)) + .when(spyRuleFactory) + .buildRules(any(MappingProfile.class)); + + var mappingProfile = createMappingProfile(null, true, null, null); + // When var actualRules = spyRuleFactory.getRules(mappingProfile); + // Then assertThat(actualRules) .hasSize(2) @@ -264,22 +256,19 @@ void getRulesShouldFilter999ffWhenSuppress999ffIsTrue() throws TransformationRul void getRulesShouldFilterSpecificFieldsWhenFieldsSuppressionIsProvided() throws TransformationRuleException { // Given - var mappingProfile = new MappingProfile(); - mappingProfile.setSuppress999ff(false); - mappingProfile.setFieldsSuppression(" 500, 700 "); - var rule100 = new Rule(); - rule100.setField("100"); - var rule500 = new Rule(); - rule500.setField("500"); - var rule700 = new Rule(); - rule700.setField("700"); - var initialRules = List.of(rule100, rule500, rule700); - // Create a spy of the injected ruleFactory to allow partial mocking of the internal buildRules - // method - var spyRuleFactory = org.mockito.Mockito.spy(ruleFactory); - doReturn(initialRules).when(spyRuleFactory).buildRules(any(MappingProfile.class)); + var mappingProfile = createMappingProfile(null, false, " 500, 700 ", null); + var rule100 = createRule(null, "100"); + var rule500 = createRule(null, "500"); + var rule700 = createRule(null, "700"); + + var spyRuleFactory = spy(ruleFactory); + doReturn(List.of(rule100, rule500, rule700)) + .when(spyRuleFactory) + .buildRules(any(MappingProfile.class)); + // When var actualRules = spyRuleFactory.getRules(mappingProfile); + // Then assertThat(actualRules).hasSize(1).containsExactly(rule100).doesNotContain(rule500, rule700); } @@ -288,29 +277,19 @@ void getRulesShouldFilterSpecificFieldsWhenFieldsSuppressionIsProvided() @TestMate(name = "TestMate-93134a9d3263b79be86f19751c59449b") void getRulesShouldApplyBoth999ffAndFieldsSuppressionSimultaneously() throws Exception { // Given - var mappingProfile = new MappingProfile(); - mappingProfile.setSuppress999ff(true); - mappingProfile.setFieldsSuppression("100"); - var translationF = new Translation(); - translationF.setParameters(Map.of("value", "f")); - var ds1 = new DataSource(); - ds1.setIndicator("1"); - ds1.setTranslation(translationF); - var ds2 = new DataSource(); - ds2.setIndicator("2"); - ds2.setTranslation(translationF); - var rule999ff = new Rule(); - rule999ff.setField("999"); - rule999ff.setDataSources(List.of(ds1, ds2)); - var rule100 = new Rule(); - rule100.setField("100"); - var rule200 = new Rule(); - rule200.setField("200"); - var initialRules = List.of(rule999ff, rule100, rule200); + var mappingProfile = createMappingProfile(null, true, "100", null); + var rule999ff = create999ffRule(); + var rule100 = createRule(null, "100"); + var rule200 = createRule(null, "200"); + var spyRuleFactory = spy(ruleFactory); - doReturn(initialRules).when(spyRuleFactory).buildRules(any(MappingProfile.class)); + doReturn(List.of(rule999ff, rule100, rule200)) + .when(spyRuleFactory) + .buildRules(any(MappingProfile.class)); + // When var actualRules = spyRuleFactory.getRules(mappingProfile); + // Then assertThat(actualRules).hasSize(1).containsExactly(rule200).doesNotContain(rule999ff, rule100); } @@ -320,18 +299,16 @@ void getRulesShouldApplyBoth999ffAndFieldsSuppressionSimultaneously() throws Exc void getRulesShouldHandleEmptyFieldsSuppressionStringGracefully() throws TransformationRuleException { // Given - var mappingProfile = new MappingProfile(); - mappingProfile.setSuppress999ff(false); - mappingProfile.setFieldsSuppression(" , , "); - var rule100 = new Rule(); - rule100.setField("100"); - var rule245 = new Rule(); - rule245.setField("245"); - var initialRules = List.of(rule100, rule245); + var mappingProfile = createMappingProfile(null, false, " , , ", null); + var rule100 = createRule(null, "100"); + var rule245 = createRule(null, "245"); + var spyRuleFactory = spy(ruleFactory); - doReturn(initialRules).when(spyRuleFactory).buildRules(any(MappingProfile.class)); + doReturn(List.of(rule100, rule245)).when(spyRuleFactory).buildRules(any(MappingProfile.class)); + // When var actualRules = spyRuleFactory.getRules(mappingProfile); + // Then assertThat(actualRules).hasSize(2).containsExactly(rule100, rule245); } @@ -341,17 +318,14 @@ void getRulesShouldHandleEmptyFieldsSuppressionStringGracefully() void buildRulesShouldCallCreateWhenMappingProfileDoesNotContainInstance() throws TransformationRuleException { // Given - var holdingsRule = new Rule(); - holdingsRule.setId("holdings.hrid"); - holdingsRule.setField("001"); - var defaultRulesFromConfigFile = new ArrayList(); - var defaultHoldingsRulesFromConfigFile = List.of(holdingsRule); - var ruleFactoryLocal = - new RuleFactory(defaultRulesFromConfigFile, defaultHoldingsRulesFromConfigFile); + var holdingsRule = createRule("holdings.hrid", "001"); + var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), List.of(holdingsRule)); var mappingProfile = new MappingProfile(); mappingProfile.setRecordTypes(List.of(RecordTypes.HOLDINGS)); + // When var actualRules = ruleFactoryLocal.buildRules(mappingProfile); + // Then assertThat(actualRules).containsExactly(holdingsRule); } @@ -360,15 +334,12 @@ void buildRulesShouldCallCreateWhenMappingProfileDoesNotContainInstance() @TestMate(name = "TestMate-60324df72f9fc56335d82b4890b76984") void buildRulesShouldCallCreateWhenMappingProfileIsNull() throws TransformationRuleException { // Given - var defaultRule = new Rule(); - defaultRule.setId("instance.hrid"); - defaultRule.setField("001"); - var defaultRulesFromConfigFile = List.of(defaultRule); - var defaultHoldingsRulesFromConfigFile = new ArrayList(); - var ruleFactoryLocal = - new RuleFactory(defaultRulesFromConfigFile, defaultHoldingsRulesFromConfigFile); + var defaultRule = createRule("instance.hrid", "001"); + var ruleFactoryLocal = new RuleFactory(List.of(defaultRule), new ArrayList<>()); + // When var actualRules = ruleFactoryLocal.buildRules(null); + // Then assertThat(actualRules).containsExactly(defaultRule); } @@ -377,22 +348,19 @@ void buildRulesShouldCallCreateWhenMappingProfileIsNull() throws TransformationR @TestMate(name = "TestMate-ff3b8fa3d9aa0238868a7fedc302cefe") void buildRulesShouldCallCreateWhenRulesFromConfigIsEmpty() throws TransformationRuleException { // Given - var instanceDefaultRule = new Rule(); - instanceDefaultRule.setId("instance.default"); - instanceDefaultRule.setField("001"); - var holdingsDefaultRule = new Rule(); - holdingsDefaultRule.setId("holdings.default"); - holdingsDefaultRule.setField("002"); - var defaultRulesFromConfigFile = List.of(instanceDefaultRule); - var defaultHoldingsRulesFromConfigFile = List.of(holdingsDefaultRule); - var ruleFactoryWithDefaults = - new RuleFactory(defaultRulesFromConfigFile, defaultHoldingsRulesFromConfigFile); + var instanceDefaultRule = createRule("instance.default", "001"); + var holdingsDefaultRule = createRule("holdings.default", "002"); + var ruleFactoryLocal = + new RuleFactory(List.of(instanceDefaultRule), List.of(holdingsDefaultRule)); + var mappingProfile = new MappingProfile(); mappingProfile.setId(UUID.fromString("f3f00482-936d-470a-819a-9769db382793")); mappingProfile.setRecordTypes(List.of(RecordTypes.INSTANCE)); mappingProfile.setTransformations(new ArrayList<>()); + // When - var actualRules = ruleFactoryWithDefaults.buildRules(mappingProfile); + var actualRules = ruleFactoryLocal.buildRules(mappingProfile); + // Then assertThat(actualRules) .hasSize(1) @@ -400,23 +368,26 @@ void buildRulesShouldCallCreateWhenRulesFromConfigIsEmpty() throws Transformatio .doesNotContain(holdingsDefaultRule); } - @Test + @Test + @TestMate(name = "TestMate-2dc55c8cc79b1f8dfcde3801e9b672a5") void createShouldAppendHoldingsDefaultRulesWhenRequested() throws TransformationRuleException { - // TestMate-2dc55c8cc79b1f8dfcde3801e9b672a5 // Given - var initialRule = new Rule(); - initialRule.setId("instance.hrid"); - var initialRules = new ArrayList<>(List.of(initialRule)); - var defaultHoldingsRule = new Rule(); - defaultHoldingsRule.setId("holdings.default"); - var defaultHoldingsRules = List.of(defaultHoldingsRule); - var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), defaultHoldingsRules); - var mappingProfile = new MappingProfile(); - mappingProfile.setId(UUID.fromString("c0a80101-0000-0000-0000-000000000001")); - mappingProfile.setRecordTypes(List.of(RecordTypes.HOLDINGS)); + var mappingProfile = + createMappingProfile( + UUID.fromString("c0a80101-0000-0000-0000-000000000001"), + false, + null, + List.of(RecordTypes.HOLDINGS)); mappingProfile.setTransformations(new ArrayList<>()); + + var initialRule = createRule("instance.hrid", null); + var initialRules = new ArrayList<>(List.of(initialRule)); + var defaultHoldingsRule = createRule("holdings.default", null); + var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), List.of(defaultHoldingsRule)); + // When var actualRules = ruleFactoryLocal.create(mappingProfile, initialRules, true); + // Then assertThat(actualRules) .isSameAs(initialRules) @@ -424,77 +395,83 @@ void createShouldAppendHoldingsDefaultRulesWhenRequested() throws Transformation .containsExactly(initialRule, defaultHoldingsRule); } - @Test + @Test + @TestMate(name = "TestMate-b230324ed45cb21c127310ac69ed7026") void createShouldGenerateRulesFromTransformations() throws TransformationRuleException { - // TestMate-b230324ed45cb21c127310ac69ed7026 // Given var customProfileId = UUID.fromString("d0a80101-0000-0000-0000-000000000001"); var mappingProfile = new MappingProfile(); mappingProfile.setId(customProfileId); var transformation = new Transformations(); transformation.setFieldId("instance.title"); - var transformations = List.of(transformation); - mappingProfile.setTransformations(transformations); + mappingProfile.setTransformations(List.of(transformation)); mappingProfile.setRecordTypes(Collections.emptyList()); + var initialDefaultRules = new ArrayList(); - var expectedRule = new Rule(); - expectedRule.setId("transformed.rule"); - var expectedRulesSet = Set.of(expectedRule); + var expectedRule = createRule("transformed.rule", null); + var spyRuleFactory = spy(ruleFactory); - doReturn(expectedRulesSet).when(spyRuleFactory).createByTransformations(transformations, initialDefaultRules); + doReturn(Set.of(expectedRule)) + .when(spyRuleFactory) + .createByTransformations(mappingProfile.getTransformations(), initialDefaultRules); + // When var actualRules = spyRuleFactory.create(mappingProfile, initialDefaultRules, false); + // Then - assertThat(actualRules) - .hasSize(1) - .containsExactly(expectedRule); - verify(spyRuleFactory).createByTransformations(transformations, initialDefaultRules); + assertThat(actualRules).hasSize(1).containsExactly(expectedRule); + verify(spyRuleFactory) + .createByTransformations(mappingProfile.getTransformations(), initialDefaultRules); } - @Test - void createShouldAppendDefaultInstanceRulesForDefaultProfile() throws TransformationRuleException { - // TestMate-56278d4dda4f2cbc4d2effc83b633b69 + @Test + @TestMate(name = "TestMate-56278d4dda4f2cbc4d2effc83b633b69") + void createShouldAppendDefaultInstanceRulesForDefaultProfile() + throws TransformationRuleException { // Given - var baselineRule = new Rule(); - baselineRule.setId("baseline.rule"); - var defaultRulesFromConfigFile = List.of(baselineRule); - var ruleFactoryLocal = new RuleFactory(defaultRulesFromConfigFile, new ArrayList<>()); - var spyRuleFactory = spy(ruleFactoryLocal); var mappingProfile = new MappingProfile(); mappingProfile.setId(UUID.fromString(DEFAULT_INSTANCE_MAPPING_PROFILE_ID)); var transformations = List.of(new Transformations()); mappingProfile.setTransformations(transformations); - var customRule = new Rule(); - customRule.setId("custom.rule"); - var customRulesSet = Set.of(customRule); - // Fix: Use eq() matcher for the first argument because anyList() is used for the second argument - doReturn(customRulesSet) + + var baselineRule = createRule("baseline.rule", null); + var ruleFactoryLocal = new RuleFactory(List.of(baselineRule), new ArrayList<>()); + var spyRuleFactory = spy(ruleFactoryLocal); + + var customRule = createRule("custom.rule", null); + doReturn(Set.of(customRule)) .when(spyRuleFactory) .createByTransformations(eq(transformations), anyList()); + // When var actualRules = spyRuleFactory.create(mappingProfile, new ArrayList<>(), false); + // Then assertThat(actualRules).hasSize(2).containsExactly(customRule, baselineRule); verify(spyRuleFactory).createByTransformations(eq(transformations), anyList()); } - @Test - void createShouldNotAppendHoldingsRulesWhenRequestedButTypeNotHoldings() throws TransformationRuleException { - // TestMate-4f84bc23a2303857eb884a745670ae71 + @Test + @TestMate(name = "TestMate-4f84bc23a2303857eb884a745670ae71") + void createShouldNotAppendHoldingsRulesWhenRequestedButTypeNotHoldings() + throws TransformationRuleException { // Given - var initialRule = new Rule(); - initialRule.setId("instance.hrid"); - var initialRules = new ArrayList<>(List.of(initialRule)); - var defaultHoldingsRule = new Rule(); - defaultHoldingsRule.setId("holdings.default"); - var defaultHoldingsRules = List.of(defaultHoldingsRule); - var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), defaultHoldingsRules); - var mappingProfile = new MappingProfile(); - mappingProfile.setId(UUID.fromString("d0a80101-0000-0000-0000-000000000001")); - mappingProfile.setRecordTypes(List.of(RecordTypes.INSTANCE)); + var mappingProfile = + createMappingProfile( + UUID.fromString("d0a80101-0000-0000-0000-000000000001"), + false, + null, + List.of(RecordTypes.INSTANCE)); mappingProfile.setTransformations(null); + + var initialRule = createRule("instance.hrid", null); + var initialRules = new ArrayList<>(List.of(initialRule)); + var defaultHoldingsRule = createRule("holdings.default", null); + var ruleFactoryLocal = new RuleFactory(new ArrayList<>(), List.of(defaultHoldingsRule)); + // When var actualRules = ruleFactoryLocal.create(mappingProfile, initialRules, true); + // Then assertThat(actualRules) .isSameAs(initialRules) @@ -503,26 +480,30 @@ void createShouldNotAppendHoldingsRulesWhenRequestedButTypeNotHoldings() throws .doesNotContain(defaultHoldingsRule); } - @Test - void createShouldPropagateTransformationRuleExceptionFromCreateByTransformations() throws TransformationRuleException { - // TestMate-25f02f01c02973ad5f8aa00674140688 + @Test + @TestMate(name = "TestMate-25f02f01c02973ad5f8aa00674140688") + void createShouldPropagateTransformationRuleExceptionFromCreateByTransformations() + throws TransformationRuleException { // Given - var mappingProfile = new MappingProfile(); - mappingProfile.setId(UUID.fromString("c0a80101-0000-0000-0000-000000000001")); - mappingProfile.setRecordTypes(List.of(RecordTypes.INSTANCE)); + var mappingProfile = + createMappingProfile( + UUID.fromString("c0a80101-0000-0000-0000-000000000001"), + false, + null, + List.of(RecordTypes.INSTANCE)); var transformations = List.of(new Transformations()); mappingProfile.setTransformations(transformations); + var defaultRules = new ArrayList(); - var exceptionMessage = "Transformation failed"; var spyRuleFactory = spy(ruleFactory); - doThrow(new TransformationRuleException(exceptionMessage)) + doThrow(new TransformationRuleException("Transformation failed")) .when(spyRuleFactory) .createByTransformations(anyList(), anyList()); - // When - var exception = assertThrows(TransformationRuleException.class, () -> - spyRuleFactory.create(mappingProfile, defaultRules, false)); - // Then - assertThat(exception.getMessage()).isEqualTo(exceptionMessage); + + // When & Then + assertThatThrownBy(() -> spyRuleFactory.create(mappingProfile, defaultRules, false)) + .isInstanceOf(TransformationRuleException.class) + .hasMessage("Transformation failed"); verify(spyRuleFactory).createByTransformations(transformations, defaultRules); } }