mirror of
https://github.com/Alfresco/alfresco-transform-core.git
synced 2026-09-16 18:12:54 +00:00
ACS-10652 Changing stepTransformer overrride logic to fix Test Failures inACS (#1243)
This commit is contained in:
Belal Ansari
@@ -2,7 +2,7 @@
|
||||
* #%L
|
||||
* Alfresco Transform Model
|
||||
* %%
|
||||
* Copyright (C) 2005 - 2022 Alfresco Software Limited
|
||||
* Copyright (C) 2005 - 2026 Alfresco Software Limited
|
||||
* %%
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as
|
||||
@@ -30,7 +30,7 @@ import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.Objects;
|
||||
import java.util.Set;
|
||||
import java.util.StringJoiner;
|
||||
import java.util.function.Function;
|
||||
@@ -235,7 +235,7 @@ public class CombinedTransformConfig
|
||||
{
|
||||
if (!CollectionUtils.isEmpty(overrideSupportedSet))
|
||||
{
|
||||
overrideSupportedSet.forEach(override -> deferredOverrides.add(new DeferredOverride(override, readFrom)));
|
||||
overrideSupportedSet.forEach(overrideSupported -> deferredOverrides.add(new DeferredOverride(overrideSupported, readFrom)));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -255,53 +255,115 @@ public class CombinedTransformConfig
|
||||
Map<String, Set<OverrideSupported>> leftoverBySource = new HashMap<>();
|
||||
for (DeferredOverride deferredOverride : deferredOverrides)
|
||||
{
|
||||
OverrideSupported override = deferredOverride.getOverrideSupported();
|
||||
OverrideSupported overrideSupported = deferredOverride.getOverrideSupported();
|
||||
String readFrom = deferredOverride.getReadFrom();
|
||||
|
||||
List<Transformer> matchedTransformers = combinedTransformers.stream()
|
||||
// --- Guard: validate exactly one transformer matches the override name ---
|
||||
List<Transformer> directMatches = combinedTransformers.stream()
|
||||
.map(Origin::get)
|
||||
.filter(transformer -> transformer.getTransformerName().equals(override.getTransformerName()))
|
||||
.filter(transformer -> transformer.getTransformerName().equals(overrideSupported.getTransformerName()))
|
||||
.collect(Collectors.toList());
|
||||
if (matchedTransformers.isEmpty())
|
||||
|
||||
if (directMatches.isEmpty())
|
||||
{
|
||||
leftoverBySource.computeIfAbsent(readFrom, k -> new HashSet<>()).add(override);
|
||||
leftoverBySource.computeIfAbsent(readFrom, k -> new HashSet<>()).add(overrideSupported);
|
||||
continue;
|
||||
}
|
||||
if (matchedTransformers.size() > 1)
|
||||
if (directMatches.size() > 1)
|
||||
{
|
||||
throw new IllegalStateException("Multiple transformers found for " + readFrom + " with name: " + override.getTransformerName() + ". This should not be possible as removeInvalidTransformers should have removed duplicates.");
|
||||
throw new IllegalStateException("Multiple transformers found for " + readFrom + " with name: " + overrideSupported.getTransformerName() + ". This should not be possible as removeInvalidTransformers should have removed duplicates.");
|
||||
}
|
||||
|
||||
Set<SupportedSourceAndTarget> supportedList = matchedTransformers.get(0).getSupportedSourceAndTargetList();
|
||||
Optional<SupportedSourceAndTarget> existingSupportedOpt = supportedList.stream()
|
||||
.filter(supported -> supported.getSourceMediaType().equals(override.getSourceMediaType()) &&
|
||||
supported.getTargetMediaType().equals(override.getTargetMediaType()))
|
||||
.findFirst();
|
||||
|
||||
if (existingSupportedOpt.isPresent())
|
||||
// --- Apply to the directly-named transformer (exact source + target match) ---
|
||||
boolean applied = applyOverrideToDirectTransformer(directMatches.get(0), overrideSupported);
|
||||
if (applied)
|
||||
{
|
||||
SupportedSourceAndTarget existingSupported = existingSupportedOpt.get();
|
||||
supportedList.remove(existingSupported);
|
||||
if (override.getMaxSourceSizeBytes() != null)
|
||||
{
|
||||
existingSupported.setMaxSourceSizeBytes(override.getMaxSourceSizeBytes());
|
||||
}
|
||||
if (override.getPriority() != null)
|
||||
{
|
||||
existingSupported.setPriority(override.getPriority());
|
||||
}
|
||||
supportedList.add(existingSupported);
|
||||
// --- Propagate to any pipeline whose first step is the overridden transformer ---
|
||||
propagateOverrideToPipelineParents(overrideSupported);
|
||||
}
|
||||
else
|
||||
{
|
||||
leftoverBySource.computeIfAbsent(readFrom, k -> new HashSet<>()).add(override);
|
||||
leftoverBySource.computeIfAbsent(readFrom, k -> new HashSet<>()).add(overrideSupported);
|
||||
}
|
||||
}
|
||||
// Warn about overrides that didn't match anything
|
||||
|
||||
// --- Warn about overrides that didn't match anything ---
|
||||
leftoverBySource.forEach((readFrom, leftOvers) -> logWarn(leftOvers, readFrom, registry, "overrideSupported"));
|
||||
deferredOverrides.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Applies the override to the entry on the directly-named transformer that matches the override's source and target media types exactly.
|
||||
*
|
||||
* @return {@code true} if a matching entry was found and updated; {@code false} if no match was found (caller should treat the override as unresolved)
|
||||
*/
|
||||
private boolean applyOverrideToDirectTransformer(Transformer transformer, OverrideSupported overrideSupported)
|
||||
{
|
||||
Set<SupportedSourceAndTarget> existingEntries = transformer.getSupportedSourceAndTargetList();
|
||||
|
||||
List<SupportedSourceAndTarget> entriesToOverride = existingEntries.stream()
|
||||
.filter(entry -> Objects.equals(overrideSupported.getSourceMediaType(), entry.getSourceMediaType()) &&
|
||||
Objects.equals(overrideSupported.getTargetMediaType(), entry.getTargetMediaType()))
|
||||
.collect(Collectors.toList());
|
||||
|
||||
return replaceEntriesWithOverrides(existingEntries, entriesToOverride, overrideSupported);
|
||||
}
|
||||
|
||||
/**
|
||||
* Propagates the override to every pipeline transformer whose first step is the overridden transformer. Matches on both source media type and the step's target media type (the intermediate type) to avoid incorrectly updating pipelines that share the same first-step transformer name but use a different intermediate type. The synthesised pipeline entry target is the final pipeline output, not the intermediate, so only the source and the step's own target are used for matching.
|
||||
*/
|
||||
private void propagateOverrideToPipelineParents(OverrideSupported overrideSupported)
|
||||
{
|
||||
List<Transformer> pipelineParents = combinedTransformers.stream()
|
||||
.map(Origin::get)
|
||||
.filter(pipeline -> !CollectionUtils.isEmpty(pipeline.getTransformerPipeline()))
|
||||
.filter(pipeline -> Objects.equals(overrideSupported.getTransformerName(), pipeline.getTransformerPipeline().get(0).getTransformerName()) &&
|
||||
Objects.equals(overrideSupported.getTargetMediaType(), pipeline.getTransformerPipeline().get(0).getTargetMediaType()))
|
||||
.collect(Collectors.toList());
|
||||
|
||||
for (Transformer pipeline : pipelineParents)
|
||||
{
|
||||
Set<SupportedSourceAndTarget> supportedList = pipeline.getSupportedSourceAndTargetList();
|
||||
List<SupportedSourceAndTarget> entriesToOverride = supportedList.stream()
|
||||
.filter(entry -> Objects.equals(overrideSupported.getSourceMediaType(), entry.getSourceMediaType()))
|
||||
.collect(Collectors.toList());
|
||||
replaceEntriesWithOverrides(supportedList, entriesToOverride, overrideSupported);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Replaces entries in the supportedList with their overridden versions if entriesToOverride is not empty.
|
||||
*
|
||||
* @return {@code true} if entries were replaced; {@code false} if entriesToOverride was empty
|
||||
*/
|
||||
private boolean replaceEntriesWithOverrides(Set<SupportedSourceAndTarget> supportedList,
|
||||
List<SupportedSourceAndTarget> entriesToOverride,
|
||||
OverrideSupported overrideSupported)
|
||||
{
|
||||
if (CollectionUtils.isEmpty(entriesToOverride))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
supportedList.removeAll(entriesToOverride);
|
||||
supportedList.addAll(entriesToOverride.stream()
|
||||
.map(entry -> applyOverride(entry, overrideSupported))
|
||||
.collect(toSet()));
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a new {@link SupportedSourceAndTarget} copied from {@code existing} with non-null override fields applied. Null override fields are left unchanged to preserve values already set by applyDefaults().
|
||||
*/
|
||||
private SupportedSourceAndTarget applyOverride(SupportedSourceAndTarget supportedEntry, OverrideSupported overrideSupported)
|
||||
{
|
||||
return SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType(supportedEntry.getSourceMediaType())
|
||||
.withTargetMediaType(supportedEntry.getTargetMediaType())
|
||||
.withMaxSourceSizeBytes(overrideSupported.getMaxSourceSizeBytes() != null ? overrideSupported.getMaxSourceSizeBytes() : supportedEntry.getMaxSourceSizeBytes())
|
||||
.withPriority(overrideSupported.getPriority() != null ? overrideSupported.getPriority() : supportedEntry.getPriority())
|
||||
.build();
|
||||
}
|
||||
|
||||
private SupportedSourceAndTarget getExistingSupported(Set<SupportedSourceAndTarget> supportedSourceAndTargetList,
|
||||
String sourceMediaType, String targetMediaType)
|
||||
{
|
||||
@@ -556,7 +618,7 @@ public class CombinedTransformConfig
|
||||
|
||||
/**
|
||||
* Sort transformers so there are no forward references, if that is possible. Logs warning message for those that have missing step transformers and removes them.
|
||||
*
|
||||
*
|
||||
* @param registry
|
||||
* used to log messages
|
||||
*/
|
||||
@@ -702,7 +764,7 @@ public class CombinedTransformConfig
|
||||
* When no supported source and target mimetypes have been defined in a failover or pipeline transformer this method adds all possible values that make sense. <lu>
|
||||
* <li>Failover - all the supported values from the step transformers</li>
|
||||
* <li>Pipeline - builds up supported source and target values. The list of source types and max sizes will come from the initial step transformer that have a target mimetype that matches the first intermediate mimetype. We then step through all intermediate transformers checking the next intermediate type is supported. When we get to the last step transformer, it provides all the target mimetypes based on the previous intermediate mimetype. Any combinations supported by the first transformer are excluded.</li> </lu>
|
||||
*
|
||||
*
|
||||
* @param registry
|
||||
* used to log messages
|
||||
*/
|
||||
@@ -866,7 +928,7 @@ public class CombinedTransformConfig
|
||||
|
||||
/**
|
||||
* Removes pipeline transformers if the step transformers cannot be chained together via the intermediary types to produce the set of claimed source and target mimetypes.
|
||||
*
|
||||
*
|
||||
* @param registry
|
||||
* used to log messages
|
||||
*/
|
||||
|
||||
+232
-59
@@ -2,7 +2,7 @@
|
||||
* #%L
|
||||
* Alfresco Transform Model
|
||||
* %%
|
||||
* Copyright (C) 2005 - 2022 Alfresco Software Limited
|
||||
* Copyright (C) 2005 - 2026 Alfresco Software Limited
|
||||
* %%
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Lesser General Public License as
|
||||
@@ -451,69 +451,242 @@ public class OverrideTransformConfigTests
|
||||
@Test
|
||||
public void testDeferredOverrideForPipelineTransformer()
|
||||
{
|
||||
// Add step transformers first
|
||||
Transformer step1 = Transformer.builder()
|
||||
.withTransformerName("step1")
|
||||
.withSupportedSourceAndTargetList(Set.of(
|
||||
SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType("mimetype/document")
|
||||
.withTargetMediaType("mimetype/pdf")
|
||||
.build()))
|
||||
.build();
|
||||
|
||||
Transformer step2 = Transformer.builder()
|
||||
.withTransformerName("step2")
|
||||
.withSupportedSourceAndTargetList(Set.of(
|
||||
SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType("mimetype/pdf")
|
||||
.withTargetMediaType("mimetype/image")
|
||||
.build()))
|
||||
.build();
|
||||
|
||||
// Add pipeline transformer
|
||||
Transformer pipelineTransformer = Transformer.builder()
|
||||
.withTransformerName("pipeline1")
|
||||
.withTransformerPipeline(List.of(
|
||||
addEngineConfig(
|
||||
stepTransformer("step1", "mimetype/document", "mimetype/pdf"),
|
||||
stepTransformer("step2", "mimetype/pdf", "mimetype/image"),
|
||||
pipelineTransformer("pipeline1",
|
||||
new TransformStep("step1", "mimetype/pdf"),
|
||||
new TransformStep("step2", null)))
|
||||
.build();
|
||||
|
||||
TransformConfig pipelineConfig = TransformConfig.builder()
|
||||
.withTransformers(List.of(step1, step2, pipelineTransformer))
|
||||
.build();
|
||||
|
||||
config.addTransformConfig(pipelineConfig, READ_FROM_A, BASE_URL_A, registry);
|
||||
|
||||
// Add override for pipeline transformer
|
||||
OverrideSupported override = OverrideSupported.builder()
|
||||
new TransformStep("step2", null)));
|
||||
addOverrideConfig(OverrideSupported.builder()
|
||||
.withTransformerName("pipeline1")
|
||||
.withSourceMediaType("mimetype/document")
|
||||
.withTargetMediaType("mimetype/image")
|
||||
.withPriority(40)
|
||||
.build();
|
||||
|
||||
TransformConfig overrideConfig = TransformConfig.builder()
|
||||
.withOverrideSupported(Set.of(override))
|
||||
.build();
|
||||
|
||||
config.addTransformConfig(overrideConfig, READ_FROM_B, BASE_URL_B, registry);
|
||||
|
||||
// Combine configs
|
||||
.withSourceMediaType("mimetype/document").withTargetMediaType("mimetype/image")
|
||||
.withPriority(40).build());
|
||||
config.combineTransformerConfig(registry);
|
||||
|
||||
// Assert override applied
|
||||
List<Transformer> transformers = config.buildTransformConfig().getTransformers();
|
||||
assertTrue(!transformers.isEmpty(), "Pipeline transformer should exist after valid setup");
|
||||
Set<SupportedSourceAndTarget> supportedList = transformers.stream()
|
||||
.filter(t -> "pipeline1".equals(t.getTransformerName()))
|
||||
.findFirst()
|
||||
.orElseThrow()
|
||||
.getSupportedSourceAndTargetList();
|
||||
assertEquals(40, getEntry(getTransformers(), "pipeline1", "mimetype/document", "mimetype/image").getPriority());
|
||||
}
|
||||
|
||||
boolean found = supportedList.stream().anyMatch(s -> "mimetype/document".equals(s.getSourceMediaType()) &&
|
||||
"mimetype/image".equals(s.getTargetMediaType()) &&
|
||||
s.getPriority() == 40);
|
||||
assertTrue(found, "Deferred override for pipeline transformer should be applied after wildcard generation");
|
||||
/**
|
||||
* An override on a leaf transformer must propagate to ALL pipeline transformers that use it as their first step, not just the first one found.
|
||||
*/
|
||||
@Test
|
||||
public void testOverridePropagatedToPipelineParents()
|
||||
{
|
||||
// step "1": a->b; used as step 0 by both pipeline "4" (a->c) and pipeline "5" (a->d)
|
||||
addEngineConfig(
|
||||
stepTransformer("1", "mimetype/a", "mimetype/b", 50, 1000L),
|
||||
stepTransformer("2", "mimetype/b", "mimetype/c"),
|
||||
stepTransformer("3", "mimetype/b", "mimetype/d"),
|
||||
pipelineTransformer("4", new TransformStep("1", "mimetype/b"), new TransformStep("2", null)),
|
||||
pipelineTransformer("5", new TransformStep("1", "mimetype/b"), new TransformStep("3", null)));
|
||||
addOverrideConfig(OverrideSupported.builder()
|
||||
.withTransformerName("1")
|
||||
.withSourceMediaType("mimetype/a").withTargetMediaType("mimetype/b")
|
||||
.withPriority(10).withMaxSourceSizeBytes(500L).build());
|
||||
config.combineTransformerConfig(registry);
|
||||
|
||||
assertEquals(0, registry.warnMessages.size());
|
||||
|
||||
List<Transformer> transformers = getTransformers();
|
||||
assertEntry(transformers, "1", "mimetype/a", "mimetype/b", 10, 500L);
|
||||
assertEntry(transformers, "4", "mimetype/a", "mimetype/c", 10, 500L);
|
||||
assertEntry(transformers, "5", "mimetype/a", "mimetype/d", 10, 500L);
|
||||
}
|
||||
|
||||
/**
|
||||
* An override whose source media type does not match any entry on the named transformer produces a warning and leaves both the direct entry and any synthesised pipeline entries unchanged.
|
||||
*/
|
||||
@Test
|
||||
public void testOverrideWithNoMatchingSourceProducesWarning()
|
||||
{
|
||||
addEngineConfig(
|
||||
stepTransformer("1", "mimetype/a", "mimetype/b", 50, 1000L),
|
||||
stepTransformer("2", "mimetype/b", "mimetype/c"),
|
||||
pipelineTransformer("3", new TransformStep("1", "mimetype/b"), new TransformStep("2", null)));
|
||||
addOverrideConfig(OverrideSupported.builder()
|
||||
.withTransformerName("1")
|
||||
.withSourceMediaType("mimetype/x").withTargetMediaType("mimetype/b") // "mimetype/x" does not exist on "1"
|
||||
.withPriority(10).build());
|
||||
config.combineTransformerConfig(registry);
|
||||
|
||||
assertEquals(1, registry.warnMessages.size());
|
||||
assertEquals("Unable to process \"overrideSupported\": [" +
|
||||
"{\"transformerName\": \"1\", \"sourceMediaType\": \"mimetype/x\", \"targetMediaType\": \"mimetype/b\", \"priority\": \"10\"}]. " +
|
||||
"Read from readFromB", registry.warnMessages.get(0));
|
||||
|
||||
List<Transformer> transformers = getTransformers();
|
||||
assertEntry(transformers, "1", "mimetype/a", "mimetype/b", 50, 1000L);
|
||||
assertEntry(transformers, "3", "mimetype/a", "mimetype/c", 50, 1000L);
|
||||
}
|
||||
|
||||
/**
|
||||
* An override on a standalone transformer (not the first step of any pipeline) applies correctly to the direct entry. propagateOverrideToPipelineParents is a no-op and no warning is produced.
|
||||
*/
|
||||
@Test
|
||||
public void testOverrideOnStandaloneTransformerHasNoPipelineImpact()
|
||||
{
|
||||
addEngineConfig(stepTransformer("1", "mimetype/a", "mimetype/b", 50, 1000L));
|
||||
addOverrideConfig(OverrideSupported.builder()
|
||||
.withTransformerName("1")
|
||||
.withSourceMediaType("mimetype/a").withTargetMediaType("mimetype/b")
|
||||
.withPriority(10).build()); // size not in override → retained
|
||||
config.combineTransformerConfig(registry);
|
||||
|
||||
assertEquals(0, registry.warnMessages.size());
|
||||
assertEntry(getTransformers(), "1", "mimetype/a", "mimetype/b", 10, 1000L);
|
||||
}
|
||||
|
||||
/**
|
||||
* When a wildcard-generated pipeline has multiple synthesised final targets (because the second step supports several output formats), an override on step 0 must propagate its constraint to every one of those entries — not just the first one found.
|
||||
*/
|
||||
@Test
|
||||
public void testOverridePropagatesMaxSizeToAllWildcardTargetsWithinSinglePipeline()
|
||||
{
|
||||
// step "2" produces three final outputs (b→c, b→d, b→e) from the intermediate
|
||||
addEngineConfig(
|
||||
stepTransformer("1", "mimetype/a", "mimetype/b", 50, 1000L),
|
||||
stepTransformerMultiTarget("2", "mimetype/b", "mimetype/c", "mimetype/d", "mimetype/e"),
|
||||
pipelineTransformer("3", new TransformStep("1", "mimetype/b"), new TransformStep("2", null)));
|
||||
addOverrideConfig(OverrideSupported.builder()
|
||||
.withTransformerName("1")
|
||||
.withSourceMediaType("mimetype/a").withTargetMediaType("mimetype/b")
|
||||
.withMaxSourceSizeBytes(786432L).build());
|
||||
config.combineTransformerConfig(registry);
|
||||
|
||||
assertEquals(0, registry.warnMessages.size());
|
||||
assertEquals(0, registry.errorMessages.size());
|
||||
|
||||
List<Transformer> transformers = getTransformers();
|
||||
assertEquals(786432L, getEntry(transformers, "1", "mimetype/a", "mimetype/b").getMaxSourceSizeBytes());
|
||||
assertEquals(786432L, getEntry(transformers, "3", "mimetype/a", "mimetype/c").getMaxSourceSizeBytes(),
|
||||
"pipeline a→c must inherit the maxSourceSizeBytes cap");
|
||||
assertEquals(786432L, getEntry(transformers, "3", "mimetype/a", "mimetype/d").getMaxSourceSizeBytes(),
|
||||
"pipeline a→d must inherit the maxSourceSizeBytes cap");
|
||||
assertEquals(786432L, getEntry(transformers, "3", "mimetype/a", "mimetype/e").getMaxSourceSizeBytes(),
|
||||
"pipeline a→e must inherit the maxSourceSizeBytes cap");
|
||||
assertEquals(3, getTransformerByName(transformers, "3").getSupportedSourceAndTargetList().size());
|
||||
}
|
||||
|
||||
/**
|
||||
* An override on a transformer that participates in a pipeline but is NOT the first step must apply only to the direct entry on that transformer. The synthesised pipeline entries must remain unchanged because their source-size constraint comes from step 0, not a later step.
|
||||
*/
|
||||
@Test
|
||||
public void testOverrideOnNonFirstStepDoesNotPropagateToParentPipeline()
|
||||
{
|
||||
// step "2" has two entries (b→c and b→d) — the override targets b→c only
|
||||
final Transformer step2 = Transformer.builder().withTransformerName("2")
|
||||
.withSupportedSourceAndTargetList(new HashSet<>(Set.of(
|
||||
SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType("mimetype/b").withTargetMediaType("mimetype/c")
|
||||
.withPriority(50).withMaxSourceSizeBytes(1000L).build(),
|
||||
SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType("mimetype/b").withTargetMediaType("mimetype/d")
|
||||
.withPriority(50).withMaxSourceSizeBytes(1000L).build())))
|
||||
.build();
|
||||
addEngineConfig(
|
||||
stepTransformer("1", "mimetype/a", "mimetype/b", 50, 1000L),
|
||||
step2,
|
||||
pipelineTransformer("3", new TransformStep("1", "mimetype/b"), new TransformStep("2", null)));
|
||||
// Override targets step "2" which is NOT the first step of pipeline "3"
|
||||
addOverrideConfig(OverrideSupported.builder()
|
||||
.withTransformerName("2")
|
||||
.withSourceMediaType("mimetype/b").withTargetMediaType("mimetype/c")
|
||||
.withMaxSourceSizeBytes(500L).build());
|
||||
config.combineTransformerConfig(registry);
|
||||
|
||||
assertEquals(0, registry.warnMessages.size());
|
||||
assertEquals(0, registry.errorMessages.size());
|
||||
|
||||
List<Transformer> transformers = getTransformers();
|
||||
assertEquals(500L, getEntry(transformers, "2", "mimetype/b", "mimetype/c").getMaxSourceSizeBytes());
|
||||
// Pipeline entries inherit from step1 (first step) — override on step2 must not touch them
|
||||
assertEquals(1000L, getEntry(transformers, "3", "mimetype/a", "mimetype/c").getMaxSourceSizeBytes(),
|
||||
"pipeline a→c must not be affected by an override on a non-first step");
|
||||
assertEquals(1000L, getEntry(transformers, "3", "mimetype/a", "mimetype/d").getMaxSourceSizeBytes(),
|
||||
"pipeline a→d must not be affected by an override on a non-first step");
|
||||
}
|
||||
|
||||
// ---- Transformer factory helpers ----
|
||||
private static Transformer stepTransformer(String name, String src, String tgt)
|
||||
{
|
||||
return Transformer.builder().withTransformerName(name)
|
||||
.withSupportedSourceAndTargetList(new HashSet<>(Set.of(
|
||||
SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType(src).withTargetMediaType(tgt).build())))
|
||||
.build();
|
||||
}
|
||||
|
||||
private static Transformer stepTransformer(String name, String src, String tgt, int priority, long maxSourceSizeBytes)
|
||||
{
|
||||
return Transformer.builder().withTransformerName(name)
|
||||
.withSupportedSourceAndTargetList(new HashSet<>(Set.of(
|
||||
SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType(src).withTargetMediaType(tgt)
|
||||
.withPriority(priority).withMaxSourceSizeBytes(maxSourceSizeBytes).build())))
|
||||
.build();
|
||||
}
|
||||
|
||||
private static Transformer stepTransformerMultiTarget(String name, String src, String... targets)
|
||||
{
|
||||
Set<SupportedSourceAndTarget> entries = new HashSet<>();
|
||||
for (String tgt : targets)
|
||||
{
|
||||
entries.add(SupportedSourceAndTarget.builder()
|
||||
.withSourceMediaType(src).withTargetMediaType(tgt).build());
|
||||
}
|
||||
return Transformer.builder().withTransformerName(name)
|
||||
.withSupportedSourceAndTargetList(entries).build();
|
||||
}
|
||||
|
||||
private static Transformer pipelineTransformer(String name, TransformStep... steps)
|
||||
{
|
||||
return Transformer.builder().withTransformerName(name)
|
||||
.withTransformerPipeline(List.of(steps)).build();
|
||||
}
|
||||
|
||||
// ---- Config registration helpers ----
|
||||
private void addEngineConfig(Transformer... transformers)
|
||||
{
|
||||
config.addTransformConfig(TransformConfig.builder()
|
||||
.withTransformers(ImmutableList.copyOf(transformers)).build(),
|
||||
READ_FROM_A, BASE_URL_A, registry);
|
||||
}
|
||||
|
||||
private void addOverrideConfig(OverrideSupported... overrides)
|
||||
{
|
||||
config.addTransformConfig(TransformConfig.builder()
|
||||
.withOverrideSupported(ImmutableSet.copyOf(overrides)).build(),
|
||||
READ_FROM_B, BASE_URL_B, registry);
|
||||
}
|
||||
|
||||
private List<Transformer> getTransformers()
|
||||
{
|
||||
return config.buildTransformConfig().getTransformers();
|
||||
}
|
||||
|
||||
// ---- Assertion helpers ----
|
||||
private void assertEntry(List<Transformer> transformers, String name, String src, String tgt,
|
||||
int expectedPriority, long expectedMaxSize)
|
||||
{
|
||||
SupportedSourceAndTarget entry = getEntry(transformers, name, src, tgt);
|
||||
assertEquals(expectedPriority, entry.getPriority());
|
||||
assertEquals(expectedMaxSize, entry.getMaxSourceSizeBytes());
|
||||
}
|
||||
|
||||
private static Transformer getTransformerByName(List<Transformer> transformers, String name)
|
||||
{
|
||||
return transformers.stream().filter(t -> name.equals(t.getTransformerName())).findFirst().orElseThrow();
|
||||
}
|
||||
|
||||
private SupportedSourceAndTarget getEntry(List<Transformer> transformers,
|
||||
String transformerName, String src, String tgt)
|
||||
{
|
||||
return transformers.stream()
|
||||
.filter(t -> transformerName.equals(t.getTransformerName()))
|
||||
.findFirst().orElseThrow()
|
||||
.getSupportedSourceAndTargetList().stream()
|
||||
.filter(e -> src.equals(e.getSourceMediaType()) && tgt.equals(e.getTargetMediaType()))
|
||||
.findFirst().orElseThrow();
|
||||
}
|
||||
|
||||
private void addTransformConfig_A2B_X2Y_100_23()
|
||||
|
||||
Reference in New Issue
Block a user