Skip to content

extraction-test :: move answer checking to IBaseDataObjectDiffHelper #1459

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
dev-mlb wants to merge 1 commit into
base: main
Choose a base branch
from
Open

extraction-test :: move answer checking to IBaseDataObjectDiffHelper #1459

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
118 changes: 115 additions & 3 deletions src/test/java/emissary/core/DiffCheckConfiguration.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,8 @@
package emissary.core;

import jakarta.annotation.Nullable;
import org.jdom2.Element;

import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
Expand All @@ -21,6 +24,16 @@ public enum DiffCheckOptions {
*/
private final Set<DiffCheckOptions> enabled;

/**
* Flag indicating if the verification is in strict mode.
*/
private final boolean strict;

/**
* The JDOM element containing expected values for lenient checks.
*/
private final Element lenientExpectationElement;

/**
* Start building a new configuration
*
Expand All @@ -36,7 +49,25 @@ public static DiffCheckConfiguration.DiffCheckBuilder configure() {
* @return a new config instance which only enables checking data
*/
public static DiffCheckConfiguration onlyCheckData() {
return new DiffCheckConfiguration(EnumSet.of(DiffCheckOptions.DATA));
return new DiffCheckConfiguration(EnumSet.of(DiffCheckOptions.DATA), true, null);
}

/**
* Check if the configuration is in strict mode
*
* @return if strict mode is enabled
*/
public boolean isStrict() {
return this.strict;
}

/**
* Accessor for the lenient expectation XML element
*
* @return the lenient expectation element
*/
public Element getLenientExpectationElement() {
return this.lenientExpectationElement;
}

/**
Expand Down Expand Up @@ -107,8 +138,21 @@ public Set<DiffCheckOptions> getEnabled() {
*
* @param enabled set of pre-configured options
*/
private DiffCheckConfiguration(final EnumSet<DiffCheckOptions> enabled) {
private DiffCheckConfiguration(final EnumSet<DiffCheckOptions> enabled, final boolean strict,
@Nullable final Element lenientExpectationElement) {
this.enabled = Collections.unmodifiableSet(enabled);
this.strict = strict;
this.lenientExpectationElement = lenientExpectationElement;
}

/**
* Creates a builder pre-populated with the settings of an existing configuration.
*
* @param prototype The configuration instance to copy from.
* @return A DiffCheckBuilder primed with the prototype's settings.
*/
public static DiffCheckBuilder from(final DiffCheckConfiguration prototype) {
return new DiffCheckBuilder(prototype);
}

/**
Expand All @@ -121,13 +165,48 @@ public static class DiffCheckBuilder {
*/
private final EnumSet<DiffCheckOptions> building;

/**
* Internal strict state tracking
*/
private boolean strict = true;

/**
* Internal element tracking for lenient modes
*/
@Nullable
private Element lenientExpectationElement = null;

/**
* Set strict processing mode behavior
*
* @param strict true to execute exact-match tracking, false for lenient checks
* @return the builder
*/
public DiffCheckBuilder setStrict(boolean strict) {
this.strict = strict;
return this;
}

/**
* Set the underlying template element to evaluate lenient parameter rules
*
* @param element the source XML mapping element
* @return the builder
*/
public DiffCheckBuilder setLenientExpectationElement(Element element) {
this.lenientExpectationElement = element;
/* Setting a lenient expectation element implies lenient mode */
this.strict = false;
return this;
}

/**
* Finish building and create the final DiffCheckConfiguration object
*
* @return a new Configuration instance with the enabled options
*/
public DiffCheckConfiguration build() {
return new DiffCheckConfiguration(building);
return new DiffCheckConfiguration(building, strict, lenientExpectationElement);
}

/**
Expand All @@ -154,13 +233,46 @@ private DiffCheckBuilder() {
building = EnumSet.noneOf(DiffCheckOptions.class);
}

/**
* Public/Package-private constructor to build from an existing configuration
*
* @param configuration the configuration to duplicate state from
*/
private DiffCheckBuilder(final DiffCheckConfiguration configuration) {
this.building = EnumSet.noneOf(DiffCheckOptions.class);

if (configuration.checkData()) {
this.building.add(DiffCheckOptions.DATA);
}
if (configuration.checkTimestamp()) {
this.building.add(DiffCheckOptions.TIMESTAMP);
}
if (configuration.checkInternalId()) {
this.building.add(DiffCheckOptions.INTERNAL_ID);
}
if (configuration.checkTransformHistory()) {
this.building.add(DiffCheckOptions.TRANSFORM_HISTORY);
}
if (configuration.performDetailedParameterDiff()) {
this.building.add(DiffCheckOptions.DETAILED_PARAMETER_DIFF);
}
if (configuration.performKeyValueParameterDiff()) {
this.building.add(DiffCheckOptions.KEY_VALUE_PARAMETER_DIFF);
}

this.strict = configuration.isStrict();
this.lenientExpectationElement = configuration.getLenientExpectationElement();
}

/**
* Reset the list of enabled options
*
* @return the builder
*/
public DiffCheckBuilder reset() {
building.clear();
this.strict = true;
this.lenientExpectationElement = null;
return this;
}

Expand Down
122 changes: 122 additions & 0 deletions src/test/java/emissary/core/DiffCheckConfigurationTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -131,4 +131,126 @@ void checkExplicit() {
DiffCheckOptions.DETAILED_PARAMETER_DIFF,
DiffCheckOptions.KEY_VALUE_PARAMETER_DIFF));
}

@Test
void testFromConfiguration() {
final DiffCheckBuilder originalBuilder = DiffCheckConfiguration.configure();
originalBuilder.enableData();
originalBuilder.enableTimestamp();
originalBuilder.enableDetailedParameterDiff();
final DiffCheckConfiguration originalConfig = originalBuilder.build();

final DiffCheckBuilder copiedBuilder = DiffCheckConfiguration.from(originalConfig);
final DiffCheckConfiguration copiedConfig = copiedBuilder.build();

assertTrue(copiedConfig.checkData());
assertTrue(copiedConfig.checkTimestamp());
assertFalse(copiedConfig.checkInternalId());
assertFalse(copiedConfig.checkTransformHistory());
assertTrue(copiedConfig.performDetailedParameterDiff());
assertFalse(copiedConfig.performKeyValueParameterDiff());
}

@Test
void testStrictMode() {
final DiffCheckBuilder builder = DiffCheckConfiguration.configure();

// Default is strict
DiffCheckConfiguration config = builder.build();
assertTrue(config.isStrict());

// Disable strict mode
builder.setStrict(false);
config = builder.build();
assertFalse(config.isStrict());

// Re-enable strict mode
builder.setStrict(true);
config = builder.build();
assertTrue(config.isStrict());
}

@Test
void testOnlyCheckDataFactory() {
final DiffCheckConfiguration config = DiffCheckConfiguration.onlyCheckData();

assertTrue(config.checkData());
assertFalse(config.checkTimestamp());
assertFalse(config.checkInternalId());
assertFalse(config.checkTransformHistory());
assertFalse(config.performDetailedParameterDiff());
assertFalse(config.performKeyValueParameterDiff());
assertEquals(1, config.getEnabled().size());
}

@Test
void testMultipleBuilderModifications() {
final DiffCheckBuilder builder = DiffCheckConfiguration.configure();

builder.enableData();
builder.enableTimestamp();
builder.enableInternalId();
builder.enableTransformHistory();

final DiffCheckConfiguration config1 = builder.build();
assertTrue(config1.checkData());
assertTrue(config1.checkTimestamp());
assertTrue(config1.checkInternalId());
assertTrue(config1.checkTransformHistory());
assertEquals(4, config1.getEnabled().size());

// Disable some options
builder.disableTimestamp();
builder.disableInternalId();

final DiffCheckConfiguration config2 = builder.build();
assertTrue(config2.checkData());
assertFalse(config2.checkTimestamp());
assertFalse(config2.checkInternalId());
assertTrue(config2.checkTransformHistory());
assertEquals(2, config2.getEnabled().size());
}

@Test
void testMutualExclusivityOfParameterDiffs() {
final DiffCheckBuilder builder = DiffCheckConfiguration.configure();

builder.enableDetailedParameterDiff();
DiffCheckConfiguration config = builder.build();
assertTrue(config.performDetailedParameterDiff());
assertFalse(config.performKeyValueParameterDiff());

// Enabling key-value should disable detailed
builder.enableKeyValueParameterDiff();
config = builder.build();
assertFalse(config.performDetailedParameterDiff());
assertTrue(config.performKeyValueParameterDiff());

// Enabling detailed should disable key-value
builder.enableDetailedParameterDiff();
config = builder.build();
assertTrue(config.performDetailedParameterDiff());
assertFalse(config.performKeyValueParameterDiff());
}

@Test
void testCumulativeEnablingAllOptions() {
final DiffCheckBuilder builder = DiffCheckConfiguration.configure();

builder.enableData();
builder.enableTimestamp();
builder.enableInternalId();
builder.enableTransformHistory();
builder.enableDetailedParameterDiff();

final DiffCheckConfiguration config = builder.build();

assertTrue(config.checkData());
assertTrue(config.checkTimestamp());
assertTrue(config.checkInternalId());
assertTrue(config.checkTransformHistory());
assertTrue(config.performDetailedParameterDiff());
assertFalse(config.performKeyValueParameterDiff());
assertEquals(5, config.getEnabled().size());
}
}
Loading
Loading