fix #920: no type change when array is wrapped in allOf (#921)

SchemaDiff#computeDiffForReal selects the diff result from right.getClass(),
so comparing a direct `type: array` against an allOf-wrapped array landed in
ComposedSchemaDiffResult with a non-composed left schema and reported a
spurious `array -> array` type change.

When the right-hand composed schema has already been flattened by
resolveComposedSchema (no oneOf left), delegate to the diff result matching
the left-hand schema instead. Array items keep being compared because
ArraySchemaDiffResult reads them through Schema#getItems().

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: DrSatyr

core/src/main/java/org/openapitools/openapidiff/core/compare/schemadiffresult/ComposedSchemaDiffResult.java

@@ -12,6 +12,7 @@
 import org.apache.commons.collections4.CollectionUtils;
 import org.openapitools.openapidiff.core.compare.MapKeyDiff;
 import org.openapitools.openapidiff.core.compare.OpenApiDiff;
+import org.openapitools.openapidiff.core.compare.SchemaDiff;
 import org.openapitools.openapidiff.core.model.ChangedSchema;
 import org.openapitools.openapidiff.core.model.DiffContext;
 import org.openapitools.openapidiff.core.model.deferred.DeferredBuilder;
@@ -98,11 +99,24 @@ public <T extends Schema<X>, X> DeferredChanged<ChangedSchema> diff(
           .build()
           .flatMap(
               values -> super.diff(refSet, leftComponents, rightComponents, left, right, context));
+    } else if (isResolvedToPlainSchema(right)) {
+      // `right` is a composed schema whose allOf/anyOf members have already been merged into it
+      // by SchemaDiff#resolveComposedSchema, so structurally it is a plain schema. Types and
+      // formats were compared in SchemaDiff#computeDiffForReal before this result was selected,
+      // so diff both sides with the result matching the left-hand schema instead of reporting a
+      // type change.
+      return SchemaDiff.getSchemaDiffResult(left.getClass(), openApiDiff)
+          .diff(refSet, leftComponents, rightComponents, left, right, context);
     } else {
       return openApiDiff.getSchemaDiff().getTypeChangedSchema(left, right, context);
     }
   }
 
+  private static boolean isResolvedToPlainSchema(Schema<?> schema) {
+    return schema instanceof ComposedSchema
+        && CollectionUtils.isEmpty(((ComposedSchema) schema).getOneOf());
+  }
+
   private Map<String, Schema> getSchema(
       Components components, Map<String, String> mapping, ComposedSchema composedSchema) {
     Map<String, Schema> result = new LinkedHashMap<>();

core/src/test/java/org/openapitools/openapidiff/core/Issue887Test.java

@@ -1,6 +1,5 @@
 package org.openapitools.openapidiff.core;
 
-import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.openapitools.openapidiff.core.TestUtils.assertOpenApiAreEquals;
 
 import org.junit.jupiter.api.Test;
@@ -11,19 +10,12 @@ public class Issue887Test {
   private final String DIRECT_ARRAY = "issue-887-2.yaml";
 
   @Test
-  public void testAllOfArrayToDirectArrayDoesNotThrow() {
-    assertThatCode(() -> OpenApiCompare.fromLocations(ALLOF_ARRAY, DIRECT_ARRAY))
-        .doesNotThrowAnyException();
-  }
-
-  @Test
-  public void testDirectArrayToAllOfArrayDoesNotThrow() {
-    assertThatCode(() -> OpenApiCompare.fromLocations(DIRECT_ARRAY, ALLOF_ARRAY))
-        .doesNotThrowAnyException();
+  public void testAllOfArrayToDirectArrayAreEquals() {
+    assertOpenApiAreEquals(ALLOF_ARRAY, DIRECT_ARRAY);
   }
 
   @Test
-  public void testAllOfArrayToDirectArrayAreEquals() {
-    assertOpenApiAreEquals(ALLOF_ARRAY, DIRECT_ARRAY);
+  public void testDirectArrayToAllOfArrayAreEquals() {
+    assertOpenApiAreEquals(DIRECT_ARRAY, ALLOF_ARRAY);
   }
 }

core/src/test/java/org/openapitools/openapidiff/core/Issue920Test.java

@@ -0,0 +1,25 @@
+package org.openapitools.openapidiff.core;
+
+import static org.openapitools.openapidiff.core.TestUtils.assertOpenApiBackwardIncompatible;
+
+import org.junit.jupiter.api.Test;
+
+public class Issue920Test {
+
+  private final String DIRECT_ARRAY_STRING_ITEM = "issue-920-1.yaml";
+  private final String ALLOF_ARRAY_INTEGER_ITEM = "issue-920-2.yaml";
+
+  /**
+   * Items must still be compared when a direct array is replaced by an allOf-wrapped array,
+   * otherwise falling through to a plain schema diff would silently hide item changes.
+   */
+  @Test
+  public void testDirectArrayToAllOfArrayDetectsChangedItemType() {
+    assertOpenApiBackwardIncompatible(DIRECT_ARRAY_STRING_ITEM, ALLOF_ARRAY_INTEGER_ITEM);
+  }
+
+  @Test
+  public void testAllOfArrayToDirectArrayDetectsChangedItemType() {
+    assertOpenApiBackwardIncompatible(ALLOF_ARRAY_INTEGER_ITEM, DIRECT_ARRAY_STRING_ITEM);
+  }
+}

core/src/test/resources/issue-920-1.yaml

@@ -0,0 +1,31 @@
+openapi: 3.0.3
+info:
+  title: Test API
+  version: 1.0.0
+
+paths:
+  /test:
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/TestResponse'
+
+components:
+  schemas:
+    TestResponse:
+      type: object
+      properties:
+        valuations:
+          type: array
+          items:
+            $ref: '#/components/schemas/Valuation'
+
+    Valuation:
+      type: object
+      properties:
+        value:
+          type: string

core/src/test/resources/issue-920-2.yaml

@@ -0,0 +1,32 @@
+openapi: 3.0.3
+info:
+  title: Test API
+  version: 1.0.0
+
+paths:
+  /test:
+    get:
+      responses:
+        '200':
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/TestResponse'
+
+components:
+  schemas:
+    TestResponse:
+      type: object
+      properties:
+        valuations:
+          allOf:
+            - $ref: '#/components/schemas/Valuations'
+
+    Valuations:
+      type: array
+      items:
+        type: object
+        properties:
+          value:
+            type: integer