disabling readOnly / writeOnly keywords in older draft versions

Author: erosb

core/src/main/java/org/everit/json/schema/loader/SchemaLoader.java

@@ -391,8 +391,10 @@ private void loadCommonSchemaProperties(Schema.Builder builder) {
         ls.schemaJson().maybe(config.specVersion.idKeyword()).map(JsonValue::requireString).ifPresent(builder::id);
         ls.schemaJson().maybe("title").map(JsonValue::requireString).ifPresent(builder::title);
         ls.schemaJson().maybe("description").map(JsonValue::requireString).ifPresent(builder::description);
-        ls.schemaJson().maybe("readOnly").map(JsonValue::requireBoolean).ifPresent(builder::readOnly);
-        ls.schemaJson().maybe("writeOnly").map(JsonValue::requireBoolean).ifPresent(builder::writeOnly);
+        if (ls.specVersion() == DRAFT_7) {
+            ls.schemaJson().maybe("readOnly").map(JsonValue::requireBoolean).ifPresent(builder::readOnly);
+            ls.schemaJson().maybe("writeOnly").map(JsonValue::requireBoolean).ifPresent(builder::writeOnly);
+        }
         if (config.nullableSupport) {
             builder.nullable(ls.schemaJson()
                     .maybe("nullable")

core/src/test/java/org/everit/json/schema/TestSupport.java

@@ -17,14 +17,15 @@
 
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
 
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.util.List;
 
 import org.everit.json.schema.loader.SchemaLoader;
-import org.junit.Assert;
 
 public class TestSupport {
 
@@ -114,8 +115,17 @@ public static SchemaLoader.SchemaLoaderBuilder v6Loader() {
         return SchemaLoader.builder().draftV6Support();
     }
 
+    public static SchemaLoader.SchemaLoaderBuilder v7Loader() {
+        return SchemaLoader.builder().draftV7Support();
+    }
+
     public static Schema loadAsV6(Object schema) {
-        SchemaLoader loader = v6Loader().schemaJson(schema).draftV6Support().build();
+        SchemaLoader loader = v6Loader().schemaJson(schema).build();
+        return loader.load().build();
+    }
+
+    public static Schema loadAsV7(Object schema) {
+        SchemaLoader loader = v7Loader().schemaJson(schema).build();
         return loader.load().build();
     }
 
@@ -138,7 +148,7 @@ public static void expectFailure(final Schema failingSchema,
         try {
             test(failingSchema, expectedPointer, input);
         } catch (ValidationException e) {
-            Assert.assertSame(expectedViolatedSchemaClass, e.getViolatedSchema().getClass());
+            assertSame(expectedViolatedSchemaClass, e.getViolatedSchema().getClass());
         }
     }
 
@@ -152,7 +162,7 @@ public static void expectFailure(final Schema failingSchema,
         try {
             test(failingSchema, expectedPointer, input);
         } catch (ValidationException e) {
-            Assert.assertSame(expectedViolatedSchema, e.getViolatedSchema());
+            assertSame(expectedViolatedSchema, e.getViolatedSchema());
         }
     }
 
@@ -164,9 +174,9 @@ public static void expectFailure(final Schema failingSchema, final String expect
     public static void expectFailure(final Failure failure) {
         try {
             failure.validator.performValidation(failure.subject, failure.input);
-            Assert.fail(failure.subject + " did not fail for " + failure.input);
+            fail(failure.subject + " did not fail for " + failure.input);
         } catch (ValidationException e) {
-            Assert.assertSame(failure.expectedViolatedSchema(), e.getViolatedSchema());
+            assertSame(failure.expectedViolatedSchema(), e.getViolatedSchema());
             assertEquals(failure.expectedPointer, e.getPointerToViolation());
             assertEquals(failure.expectedSchemaLocation, e.getSchemaLocation());
             if (failure.expectedKeyword != null) {
@@ -186,7 +196,7 @@ private static void test(final Schema failingSchema, final String expectedPointe
             final Object input) {
         try {
             failingSchema.validate(input);
-            Assert.fail(failingSchema + " did not fail for " + input);
+            fail(failingSchema + " did not fail for " + input);
         } catch (ValidationException e) {
             if (expectedPointer != null) {
                 assertEquals(expectedPointer, e.getPointerToViolation());

core/src/test/java/org/everit/json/schema/ValidatorTest.java

@@ -1,17 +1,16 @@
 package org.everit.json.schema;
 
+import static org.everit.json.schema.TestSupport.loadAsV7;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import org.everit.json.schema.loader.SchemaLoader;
 import org.json.JSONObject;
 import org.junit.Test;
 
 public class ValidatorTest {
 
-    private static final ObjectSchema RW_SCHEMA = (ObjectSchema) SchemaLoader
-            .load(ResourceLoader.DEFAULT.readObj("read-write-context.json"));
+    private static final ObjectSchema RW_SCHEMA = (ObjectSchema) loadAsV7(ResourceLoader.DEFAULT.readObj("read-write-context.json"));
 
     @Test
     public void testCollectAllMode() {

core/src/test/java/org/everit/json/schema/loader/ReadWriteContextLoadingTest.java

@@ -1,5 +1,8 @@
 package org.everit.json.schema.loader;
 
+import static org.everit.json.schema.TestSupport.loadAsV6;
+import static org.everit.json.schema.TestSupport.loadAsV7;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 
 import org.everit.json.schema.ObjectSchema;
@@ -13,16 +16,25 @@ public class ReadWriteContextLoadingTest {
 
     @Test
     public void testReadOnlyContext() {
-        ObjectSchema rootSchema = (ObjectSchema) SchemaLoader.load(LOADER.readObj("read-write-context.json"));
+        ObjectSchema rootSchema = (ObjectSchema) loadAsV7(LOADER.readObj("read-write-context.json"));
         Schema readOnlyProp = rootSchema.getPropertySchemas().get("readOnlyProp");
         assertTrue(readOnlyProp.isReadOnly());
     }
 
     @Test
     public void testWriteOnlyContext() {
-        ObjectSchema rootSchema = (ObjectSchema) SchemaLoader.load(LOADER.readObj("read-write-context.json"));
-        Schema readOnlyProp = rootSchema.getPropertySchemas().get("writeOnlyProp");
-        assertTrue(readOnlyProp.isWriteOnly());
+        ObjectSchema rootSchema = (ObjectSchema) loadAsV7(LOADER.readObj("read-write-context.json"));
+        Schema writeOnlyProp = rootSchema.getPropertySchemas().get("writeOnlyProp");
+        assertTrue(writeOnlyProp.isWriteOnly());
+    }
+
+    @Test
+    public void worksOnlyInV7Mode() {
+        ObjectSchema rootSchema = (ObjectSchema) loadAsV6(LOADER.readObj("read-write-context.json"));
+        Schema readOnlyProp = rootSchema.getPropertySchemas().get("readOnlyProp");
+        Schema writeOnlyProp = rootSchema.getPropertySchemas().get("writeOnlyProp");
+        assertNull(readOnlyProp.isReadOnly());
+        assertNull(writeOnlyProp.isWriteOnly());
     }
 
 }