| // *************************************************************************************************************************** |
| // * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * |
| // * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * |
| // * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance * |
| // * with the License. You may obtain a copy of the License at * |
| // * * |
| // * http://www.apache.org/licenses/LICENSE-2.0 * |
| // * * |
| // * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an * |
| // * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * |
| // * specific language governing permissions and limitations under the License. * |
| // *************************************************************************************************************************** |
| package org.apache.juneau.httppart; |
| |
| import static org.junit.Assert.*; |
| |
| import static org.apache.juneau.testutils.TestUtils.*; |
| import static org.apache.juneau.internal.StringUtils.*; |
| import org.apache.juneau.*; |
| import org.apache.juneau.http.annotation.*; |
| import org.apache.juneau.jsonschema.annotation.Items; |
| import org.apache.juneau.jsonschema.annotation.SubItems; |
| import org.apache.juneau.reflect.*; |
| import org.apache.juneau.utils.*; |
| import org.junit.*; |
| import org.junit.runners.*; |
| |
| @FixMethodOrder(MethodSorters.NAME_ASCENDING) |
| public class HttpPartSchemaTest_FormData { |
| |
| //----------------------------------------------------------------------------------------------------------------- |
| // Basic test |
| //----------------------------------------------------------------------------------------------------------------- |
| @Test |
| public void testBasic() throws Exception { |
| HttpPartSchema.create().build(); |
| } |
| |
| //----------------------------------------------------------------------------------------------------------------- |
| // @FormData |
| //----------------------------------------------------------------------------------------------------------------- |
| |
| @FormData("x") |
| public static class A01 {} |
| |
| @Test |
| public void a01_value() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, A01.class).build(); |
| assertEquals("x", s.getName()); |
| } |
| |
| @FormData( |
| name="x", |
| type="number", |
| format="int32", |
| collectionFormat="csv", |
| maximum="1", |
| minimum="2", |
| multipleOf="3", |
| pattern="4", |
| maxLength=1, |
| minLength=2, |
| maxItems=3, |
| minItems=4, |
| exclusiveMaximum=true, |
| exclusiveMinimum=true, |
| uniqueItems=true, |
| required=true, |
| skipIfEmpty=true, |
| description={"b1","b2"}, |
| _default={"c1","c2"}, |
| items=@Items($ref="d1"), |
| _enum="e1,e2,e3", |
| example="f1", |
| api="{g1:true}" |
| ) |
| public static class A02 {} |
| |
| @Test |
| public void a02_basic_onClass() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, A02.class).noValidate().build(); |
| assertEquals("x", s.getName()); |
| assertEquals(HttpPartSchema.Type.NUMBER, s.getType()); |
| assertEquals(HttpPartSchema.Format.INT32, s.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.CSV, s.getCollectionFormat()); |
| assertEquals(1, s.getMaximum()); |
| assertEquals(2, s.getMinimum()); |
| assertEquals(3, s.getMultipleOf()); |
| assertEquals("4", s.getPattern().pattern()); |
| assertEquals(1, s.getMaxLength().longValue()); |
| assertEquals(2, s.getMinLength().longValue()); |
| assertEquals(3, s.getMaxItems().longValue()); |
| assertEquals(4, s.getMinItems().longValue()); |
| assertTrue(s.isExclusiveMaximum()); |
| assertTrue(s.isExclusiveMinimum()); |
| assertTrue(s.isUniqueItems()); |
| assertTrue(s.isRequired()); |
| assertTrue(s.isSkipIfEmpty()); |
| assertObjectEquals("['e1','e2','e3']", s.getEnum()); |
| assertEquals("c1\nc2", s.getDefault()); |
| } |
| |
| public static class A03 { |
| public void a( |
| @FormData( |
| name="x", |
| type="number", |
| format="int32", |
| collectionFormat="csv", |
| maximum="1", |
| minimum="2", |
| multipleOf="3", |
| pattern="4", |
| maxLength=1, |
| minLength=2, |
| maxItems=3, |
| minItems=4, |
| exclusiveMaximum=true, |
| exclusiveMinimum=true, |
| uniqueItems=true, |
| required=true, |
| skipIfEmpty=true, |
| description={"b1","b2"}, |
| _default={"c1","c2"}, |
| items=@Items($ref="d1"), |
| _enum="e1,e2,e3", |
| example="f1", |
| api="{g1:true}" |
| ) String x |
| ) { |
| |
| } |
| } |
| |
| @Test |
| public void a03_basic_onParameter() throws Exception { |
| ParamInfo mpi = MethodInfo.of(A03.class.getMethod("a", String.class)).getParam(0); |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, mpi).noValidate().build(); |
| assertEquals("x", s.getName()); |
| assertEquals(HttpPartSchema.Type.NUMBER, s.getType()); |
| assertEquals(HttpPartSchema.Format.INT32, s.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.CSV, s.getCollectionFormat()); |
| assertEquals(1, s.getMaximum()); |
| assertEquals(2, s.getMinimum()); |
| assertEquals(3, s.getMultipleOf()); |
| assertEquals("4", s.getPattern().pattern()); |
| assertEquals(1, s.getMaxLength().longValue()); |
| assertEquals(2, s.getMinLength().longValue()); |
| assertEquals(3, s.getMaxItems().longValue()); |
| assertEquals(4, s.getMinItems().longValue()); |
| assertTrue(s.isExclusiveMaximum()); |
| assertTrue(s.isExclusiveMinimum()); |
| assertTrue(s.isUniqueItems()); |
| assertTrue(s.isRequired()); |
| assertTrue(s.isSkipIfEmpty()); |
| assertObjectEquals("['e1','e2','e3']", s.getEnum()); |
| assertEquals("c1\nc2", s.getDefault()); |
| } |
| |
| public static class A04 { |
| public void a( |
| @FormData( |
| name="y", |
| type="integer", |
| format="int64", |
| collectionFormat="ssv", |
| maximum="5", |
| minimum="6", |
| multipleOf="7", |
| pattern="8", |
| maxLength=5, |
| minLength=6, |
| maxItems=7, |
| minItems=8, |
| exclusiveMaximum=false, |
| exclusiveMinimum=false, |
| uniqueItems=false, |
| required=false, |
| skipIfEmpty=false, |
| description={"b3","b3"}, |
| _default={"c3","c4"}, |
| items=@Items($ref="d2"), |
| _enum="e4,e5,e6", |
| example="f2", |
| api="{g2:true}" |
| ) A01 x |
| ) { |
| |
| } |
| } |
| |
| @Test |
| public void a04_basic_onParameterAndClass() throws Exception { |
| ParamInfo mpi = MethodInfo.of(A04.class.getMethod("a", A01.class)).getParam(0); |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, mpi).noValidate().build(); |
| assertEquals("y", s.getName()); |
| assertEquals(HttpPartSchema.Type.INTEGER, s.getType()); |
| assertEquals(HttpPartSchema.Format.INT64, s.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.SSV, s.getCollectionFormat()); |
| assertEquals(5, s.getMaximum()); |
| assertEquals(6, s.getMinimum()); |
| assertEquals(7, s.getMultipleOf()); |
| assertEquals("8", s.getPattern().pattern()); |
| assertEquals(5, s.getMaxLength().longValue()); |
| assertEquals(6, s.getMinLength().longValue()); |
| assertEquals(7, s.getMaxItems().longValue()); |
| assertEquals(8, s.getMinItems().longValue()); |
| assertFalse(s.isExclusiveMaximum()); |
| assertFalse(s.isExclusiveMinimum()); |
| assertFalse(s.isUniqueItems()); |
| assertFalse(s.isRequired()); |
| assertFalse(s.isSkipIfEmpty()); |
| assertObjectEquals("['e4','e5','e6']", s.getEnum()); |
| assertEquals("c3\nc4", s.getDefault()); |
| } |
| |
| @FormData( |
| name="x", |
| items=@Items( |
| type="number", |
| format="int32", |
| collectionFormat="csv", |
| maximum="1", |
| minimum="2", |
| multipleOf="3", |
| pattern="4", |
| maxLength=1, |
| minLength=2, |
| maxItems=3, |
| minItems=4, |
| exclusiveMaximum=true, |
| exclusiveMinimum=true, |
| uniqueItems=true, |
| _default={"c1","c2"}, |
| _enum="e1,e2", |
| items=@SubItems( |
| type="integer", |
| format="int64", |
| collectionFormat="ssv", |
| maximum="5", |
| minimum="6", |
| multipleOf="7", |
| pattern="8", |
| maxLength=5, |
| minLength=6, |
| maxItems=7, |
| minItems=8, |
| exclusiveMaximum=false, |
| exclusiveMinimum=false, |
| uniqueItems=false, |
| _default={"c3","c4"}, |
| _enum="e3,e4", |
| items={ |
| "type:'string',", |
| "format:'float',", |
| "collectionFormat:'tsv',", |
| "maximum:'9',", |
| "minimum:'10',", |
| "multipleOf:'11',", |
| "pattern:'12',", |
| "maxLength:9,", |
| "minLength:10,", |
| "maxItems:11,", |
| "minItems:12,", |
| "exclusiveMaximum:true,", |
| "exclusiveMinimum:true,", |
| "uniqueItems:true,", |
| "default:'c5\\nc6',", |
| "enum:['e5','e6'],", |
| "items:{", |
| "type:'array',", |
| "format:'double',", |
| "collectionFormat:'pipes',", |
| "maximum:'13',", |
| "minimum:'14',", |
| "multipleOf:'15',", |
| "pattern:'16',", |
| "maxLength:13,", |
| "minLength:14,", |
| "maxItems:15,", |
| "minItems:16,", |
| "exclusiveMaximum:false,", |
| "exclusiveMinimum:false,", |
| "uniqueItems:false,", |
| "default:'c7\\nc8',", |
| "enum:['e7','e8']", |
| "}" |
| } |
| ) |
| ) |
| ) |
| public static class A05 {} |
| |
| @Test |
| public void a05_basic_nestedItems_onClass() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, A05.class).noValidate().build(); |
| assertEquals("x", s.getName()); |
| |
| HttpPartSchema items = s.getItems(); |
| assertEquals(HttpPartSchema.Type.NUMBER, items.getType()); |
| assertEquals(HttpPartSchema.Format.INT32, items.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.CSV, items.getCollectionFormat()); |
| assertEquals(1, items.getMaximum()); |
| assertEquals(2, items.getMinimum()); |
| assertEquals(3, items.getMultipleOf()); |
| assertEquals("4", items.getPattern().pattern()); |
| assertEquals(1, items.getMaxLength().longValue()); |
| assertEquals(2, items.getMinLength().longValue()); |
| assertEquals(3, items.getMaxItems().longValue()); |
| assertEquals(4, items.getMinItems().longValue()); |
| assertTrue(items.isExclusiveMaximum()); |
| assertTrue(items.isExclusiveMinimum()); |
| assertTrue(items.isUniqueItems()); |
| assertObjectEquals("['e1','e2']", items.getEnum()); |
| assertEquals("c1\nc2", items.getDefault()); |
| |
| items = items.getItems(); |
| assertEquals(HttpPartSchema.Type.INTEGER, items.getType()); |
| assertEquals(HttpPartSchema.Format.INT64, items.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.SSV, items.getCollectionFormat()); |
| assertEquals(5, items.getMaximum()); |
| assertEquals(6, items.getMinimum()); |
| assertEquals(7, items.getMultipleOf()); |
| assertEquals("8", items.getPattern().pattern()); |
| assertEquals(5, items.getMaxLength().longValue()); |
| assertEquals(6, items.getMinLength().longValue()); |
| assertEquals(7, items.getMaxItems().longValue()); |
| assertEquals(8, items.getMinItems().longValue()); |
| assertFalse(items.isExclusiveMaximum()); |
| assertFalse(items.isExclusiveMinimum()); |
| assertFalse(items.isUniqueItems()); |
| assertObjectEquals("['e3','e4']", items.getEnum()); |
| assertEquals("c3\nc4", items.getDefault()); |
| |
| items = items.getItems(); |
| assertEquals(HttpPartSchema.Type.STRING, items.getType()); |
| assertEquals(HttpPartSchema.Format.FLOAT, items.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.TSV, items.getCollectionFormat()); |
| assertEquals(9, items.getMaximum()); |
| assertEquals(10, items.getMinimum()); |
| assertEquals(11, items.getMultipleOf()); |
| assertEquals("12", items.getPattern().pattern()); |
| assertEquals(9, items.getMaxLength().longValue()); |
| assertEquals(10, items.getMinLength().longValue()); |
| assertEquals(11, items.getMaxItems().longValue()); |
| assertEquals(12, items.getMinItems().longValue()); |
| assertTrue(items.isExclusiveMaximum()); |
| assertTrue(items.isExclusiveMinimum()); |
| assertTrue(items.isUniqueItems()); |
| assertObjectEquals("['e5','e6']", items.getEnum()); |
| assertEquals("c5\nc6", items.getDefault()); |
| |
| items = items.getItems(); |
| assertEquals(HttpPartSchema.Type.ARRAY, items.getType()); |
| assertEquals(HttpPartSchema.Format.DOUBLE, items.getFormat()); |
| assertEquals(HttpPartSchema.CollectionFormat.PIPES, items.getCollectionFormat()); |
| assertEquals(13, items.getMaximum()); |
| assertEquals(14, items.getMinimum()); |
| assertEquals(15, items.getMultipleOf()); |
| assertEquals("16", items.getPattern().pattern()); |
| assertEquals(13, items.getMaxLength().longValue()); |
| assertEquals(14, items.getMinLength().longValue()); |
| assertEquals(15, items.getMaxItems().longValue()); |
| assertEquals(16, items.getMinItems().longValue()); |
| assertFalse(items.isExclusiveMaximum()); |
| assertFalse(items.isExclusiveMinimum()); |
| assertFalse(items.isUniqueItems()); |
| assertObjectEquals("['e7','e8']", items.getEnum()); |
| assertEquals("c7\nc8", items.getDefault()); |
| } |
| |
| //----------------------------------------------------------------------------------------------------------------- |
| // String input validations. |
| //----------------------------------------------------------------------------------------------------------------- |
| |
| @FormData(required=true) |
| public static class B01a {} |
| |
| @Test |
| public void b01a_required() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B01a.class).build(); |
| |
| s.validateInput("x"); |
| |
| try { |
| s.validateInput(null); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("No value specified.", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateInput(""); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Empty value not allowed.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(allowEmptyValue=true) |
| public static class B01b {} |
| |
| @Test |
| public void b01b_allowEmptyValue() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B01b.class).build(); |
| |
| s.validateInput(""); |
| s.validateInput(null); |
| } |
| |
| @FormData(required=true,allowEmptyValue=true) |
| public static class B01c {} |
| |
| @Test |
| public void b01b_required_allowEmptyValue() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B01c.class).build(); |
| |
| s.validateInput(""); |
| |
| try { |
| s.validateInput(null); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("No value specified.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(pattern="x.*") |
| public static class B02a {} |
| |
| @Test |
| public void b02a_pattern() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B02a.class).build(); |
| s.validateInput("x"); |
| s.validateInput("xx"); |
| try { |
| s.validateInput("y"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match expected pattern. Must match pattern: x.*", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateInput("yx"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match expected pattern. Must match pattern: x.*", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateInput(""); // Empty headers are never allowed. |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Empty value not allowed.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(minLength=2, maxLength=3) |
| public static class B03a {} |
| |
| @Test |
| public void b03a_length() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B03a.class).build(); |
| s.validateInput("12"); |
| s.validateInput("123"); |
| s.validateInput(null); |
| try { |
| s.validateInput("1"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum length of value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateInput("1234"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum length of value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| minLength=2, maxLength=3, |
| items=@SubItems( |
| minLength=3, maxLength=4, |
| items={ |
| "minLength:4,maxLength:5,", |
| "items:{minLength:5,maxLength:6}" |
| } |
| ) |
| ) |
| ) |
| public static class B03b {} |
| |
| @Test |
| public void b03b_length_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B03b.class).build(); |
| |
| s.getItems().validateInput("12"); |
| s.getItems().getItems().validateInput("123"); |
| s.getItems().getItems().getItems().validateInput("1234"); |
| s.getItems().getItems().getItems().getItems().validateInput("12345"); |
| |
| s.getItems().validateInput("123"); |
| s.getItems().getItems().validateInput("1234"); |
| s.getItems().getItems().getItems().validateInput("12345"); |
| s.getItems().getItems().getItems().getItems().validateInput("123456"); |
| |
| s.getItems().validateInput(null); |
| s.getItems().getItems().validateInput(null); |
| s.getItems().getItems().getItems().validateInput(null); |
| s.getItems().getItems().getItems().getItems().validateInput(null); |
| |
| try { |
| s.getItems().validateInput("1"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum length of value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateInput("12"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum length of value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateInput("123"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum length of value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateInput("1234"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum length of value not met.", e.getLocalizedMessage()); |
| } |
| |
| try { |
| s.getItems().validateInput("1234"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum length of value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateInput("12345"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum length of value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateInput("123456"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum length of value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateInput("1234567"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum length of value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(_enum="X,Y") |
| public static class B04a {} |
| |
| @Test |
| public void b04a_enum() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B04a.class).build(); |
| s.validateInput("X"); |
| s.validateInput("Y"); |
| s.validateInput(null); |
| try { |
| s.validateInput("Z"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['X','Y']", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(_enum=" X , Y ") |
| public static class B04b {} |
| |
| @Test |
| public void b04b_enum() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B04b.class).build(); |
| s.validateInput("X"); |
| s.validateInput("Y"); |
| s.validateInput(null); |
| try { |
| s.validateInput("Z"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['X','Y']", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(_enum="['X','Y']") |
| public static class B04c {} |
| |
| @Test |
| public void b04c_enum_json() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B04c.class).build(); |
| s.validateInput("X"); |
| s.validateInput("Y"); |
| s.validateInput(null); |
| try { |
| s.validateInput("Z"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['X','Y']", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| _enum="['W']", |
| items=@SubItems( |
| _enum="['X']", |
| items={ |
| "enum:['Y'],", |
| "items:{enum:['Z']}" |
| } |
| ) |
| ) |
| ) |
| public static class B04d {} |
| |
| @Test |
| public void b04d_enum_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, B04d.class).build(); |
| |
| s.getItems().validateInput("W"); |
| s.getItems().getItems().validateInput("X"); |
| s.getItems().getItems().getItems().validateInput("Y"); |
| s.getItems().getItems().getItems().getItems().validateInput("Z"); |
| |
| try { |
| s.getItems().validateInput("V"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['W']", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateInput("V"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['X']", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateInput("V"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['Y']", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateInput("V"); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Value does not match one of the expected values. Must be one of the following: ['Z']", e.getLocalizedMessage()); |
| } |
| } |
| |
| //----------------------------------------------------------------------------------------------------------------- |
| // Numeric validations |
| //----------------------------------------------------------------------------------------------------------------- |
| |
| @FormData(minimum="10", maximum="100") |
| public static class C01a {} |
| |
| @Test |
| public void c01a_minmax_ints() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C01a.class).build(); |
| s.validateOutput(10, BeanContext.DEFAULT); |
| s.validateOutput(100, BeanContext.DEFAULT); |
| s.validateOutput(null, BeanContext.DEFAULT); |
| try { |
| s.validateOutput(9, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateOutput(101, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| minimum="10", maximum="100", |
| items=@SubItems( |
| minimum="100", maximum="1000", |
| items={ |
| "minimum:1000,maximum:10000,", |
| "items:{minimum:10000,maximum:100000}" |
| } |
| ) |
| ) |
| ) |
| public static class C01b {} |
| |
| @Test |
| public void c01b_minmax_ints_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C01b.class).build(); |
| |
| s.getItems().validateOutput(10, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(100, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1000, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10000, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(100, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(1000, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(10000, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(100000, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(9, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(99, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(999, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(9999, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| |
| try { |
| s.getItems().validateOutput(101, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(1001, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(10001, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(100001, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(minimum="10", maximum="100", exclusiveMinimum=true, exclusiveMaximum=true) |
| public static class C02a {} |
| |
| @Test |
| public void c02a_minmax_exclusive() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C02a.class).build(); |
| s.validateOutput(11, BeanContext.DEFAULT); |
| s.validateOutput(99, BeanContext.DEFAULT); |
| s.validateOutput(null, BeanContext.DEFAULT); |
| try { |
| s.validateOutput(10, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateOutput(100, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| minimum="10", maximum="100", exclusiveMinimum=true, exclusiveMaximum=true, |
| items=@SubItems( |
| minimum="100", maximum="1000", exclusiveMinimum=true, exclusiveMaximum=true, |
| items={ |
| "minimum:1000,maximum:10000,exclusiveMinimum:true,exclusiveMaximum:true,", |
| "items:{minimum:10000,maximum:100000,exclusiveMinimum:true,exclusiveMaximum:true}" |
| } |
| ) |
| ) |
| ) |
| public static class C02b {} |
| |
| @Test |
| public void c02b_minmax_exclusive_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C02b.class).build(); |
| |
| s.getItems().validateOutput(11, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(101, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1001, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10001, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(99, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(999, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(9999, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(99999, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(10, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(100, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(1000, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(10000, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| |
| try { |
| s.getItems().validateOutput(100, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(1000, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(10000, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(100000, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(minimum="10.1", maximum="100.1") |
| public static class C03a {} |
| |
| @Test |
| public void c03_minmax_floats() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C03a.class).build(); |
| s.validateOutput(10.1f, BeanContext.DEFAULT); |
| s.validateOutput(100.1f, BeanContext.DEFAULT); |
| s.validateOutput(null, BeanContext.DEFAULT); |
| try { |
| s.validateOutput(10f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateOutput(100.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| minimum="10.1", maximum="100.1", |
| items=@SubItems( |
| minimum="100.1", maximum="1000.1", |
| items={ |
| "minimum:1000.1,maximum:10000.1,", |
| "items:{minimum:10000.1,maximum:100000.1}" |
| } |
| ) |
| ) |
| ) |
| public static class C03b {} |
| |
| @Test |
| public void c03b_minmax_floats_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C03b.class).build(); |
| |
| s.getItems().validateOutput(10.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(100.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1000.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10000.1f, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(100.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(1000.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(10000.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(100000.1f, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(10f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(100f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(1000f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(10000f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| |
| try { |
| s.getItems().validateOutput(100.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(1000.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(10000.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(100000.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(minimum="10.1", maximum="100.1", exclusiveMinimum=true, exclusiveMaximum=true) |
| public static class C04a {} |
| |
| @Test |
| public void c04a_minmax_floats_exclusive() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C04a.class).build(); |
| s.validateOutput(10.2f, BeanContext.DEFAULT); |
| s.validateOutput(100f, BeanContext.DEFAULT); |
| s.validateOutput(null, BeanContext.DEFAULT); |
| try { |
| s.validateOutput(10.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.validateOutput(100.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| minimum="10.1", maximum="100.1", exclusiveMinimum=true, exclusiveMaximum=true, |
| items=@SubItems( |
| minimum="100.1", maximum="1000.1", exclusiveMinimum=true, exclusiveMaximum=true, |
| items={ |
| "minimum:1000.1,maximum:10000.1,exclusiveMinimum:true,exclusiveMaximum:true,", |
| "items:{minimum:10000.1,maximum:100000.1,exclusiveMinimum:true,exclusiveMaximum:true}" |
| } |
| ) |
| ) |
| ) |
| public static class C04b {} |
| |
| @Test |
| public void c04b_minmax_floats_exclusive_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C04b.class).build(); |
| |
| s.getItems().validateOutput(10.2f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(100.2f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1000.2f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10000.2f, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(100f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(1000f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(10000f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(100000f, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(10.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(100.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(1000.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(10000.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum value not met.", e.getLocalizedMessage()); |
| } |
| |
| try { |
| s.getItems().validateOutput(100.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(1000.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(10000.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(100000.1f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum value exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(multipleOf="10") |
| public static class C05a {} |
| |
| @Test |
| public void c05a_multipleOf() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C05a.class).build(); |
| s.validateOutput(0, BeanContext.DEFAULT); |
| s.validateOutput(10, BeanContext.DEFAULT); |
| s.validateOutput(20, BeanContext.DEFAULT); |
| s.validateOutput(10f, BeanContext.DEFAULT); |
| s.validateOutput(20f, BeanContext.DEFAULT); |
| s.validateOutput(null, BeanContext.DEFAULT); |
| try { |
| s.validateOutput(11, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| multipleOf="10", |
| items=@SubItems( |
| multipleOf="100", |
| items={ |
| "multipleOf:1000,", |
| "items:{multipleOf:10000}" |
| } |
| ) |
| ) |
| ) |
| public static class C05b {} |
| |
| @Test |
| public void c05b_multipleOf_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C05b.class).build(); |
| |
| s.getItems().validateOutput(0, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(0, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(0, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(0, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(10, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(100, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1000, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10000, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(20, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(200, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(2000, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(20000, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(10f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(100f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1000f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10000f, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(20f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(200f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(2000f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(20000f, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(11, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(101, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(1001, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(10001, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData(multipleOf="10.1") |
| public static class C06a {} |
| |
| @Test |
| public void c06a_multipleOf_floats() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C06a.class).build(); |
| s.validateOutput(0, BeanContext.DEFAULT); |
| s.validateOutput(10.1f, BeanContext.DEFAULT); |
| s.validateOutput(20.2f, BeanContext.DEFAULT); |
| s.validateOutput(null, BeanContext.DEFAULT); |
| try { |
| s.validateOutput(10.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| multipleOf="10.1", |
| items=@SubItems( |
| multipleOf="100.1", |
| items={ |
| "multipleOf:1000.1,", |
| "items:{multipleOf:10000.1}" |
| } |
| ) |
| ) |
| ) |
| public static class C06b {} |
| |
| @Test |
| public void c06b_multipleOf_floats_items() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, C06b.class).build(); |
| |
| s.getItems().validateOutput(0, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(0, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(0, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(0, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(10.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(100.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(1000.1f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(10000.1f, BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(20.2f, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(200.2f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(2000.2f, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(20000.2f, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(10.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(100.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(1000.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(10000.2f, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Multiple-of not met.", e.getLocalizedMessage()); |
| } |
| } |
| |
| //----------------------------------------------------------------------------------------------------------------- |
| // Collections/Array validations |
| //----------------------------------------------------------------------------------------------------------------- |
| |
| @FormData( |
| items=@Items( |
| uniqueItems=true, |
| items=@SubItems( |
| uniqueItems=true, |
| items={ |
| "uniqueItems:true,", |
| "items:{uniqueItems:true}" |
| } |
| ) |
| ) |
| |
| ) |
| public static class D01 {} |
| |
| @Test |
| public void d01a_uniqueItems_arrays() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, D01.class).build(); |
| |
| String[] good = split("a,b"), bad = split("a,a"); |
| |
| s.getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().validateOutput(null, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @Test |
| public void d01b_uniqueItems_collections() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, D01.class).build(); |
| |
| AList<String> |
| good = new AList<String>().appendAll(split("a,b")), |
| bad = new AList<String>().appendAll(split("a,a")); |
| |
| s.getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(good, BeanContext.DEFAULT); |
| s.getItems().validateOutput(null, BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(bad, BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Duplicate items not allowed.", e.getLocalizedMessage()); |
| } |
| } |
| |
| @FormData( |
| items=@Items( |
| minItems=1, maxItems=2, |
| items=@SubItems( |
| minItems=2, maxItems=3, |
| items={ |
| "minItems:3,maxItems:4,", |
| "items:{minItems:4,maxItems:5}" |
| } |
| ) |
| ) |
| |
| ) |
| public static class D02 {} |
| |
| @Test |
| public void d02a_minMaxItems_arrays() throws Exception { |
| HttpPartSchema s = HttpPartSchema.create().apply(FormData.class, D02.class).build(); |
| |
| s.getItems().validateOutput(split("1"), BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(split("1,2"), BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(split("1,2,3"), BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(split("1,2,3,4"), BeanContext.DEFAULT); |
| |
| s.getItems().validateOutput(split("1,2"), BeanContext.DEFAULT); |
| s.getItems().getItems().validateOutput(split("1,2,3"), BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().validateOutput(split("1,2,3,4"), BeanContext.DEFAULT); |
| s.getItems().getItems().getItems().getItems().validateOutput(split("1,2,3,4,5"), BeanContext.DEFAULT); |
| |
| try { |
| s.getItems().validateOutput(new String[0], BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum number of items not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(split("1"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum number of items not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(split("1,2"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum number of items not met.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(split("1,2,3"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Minimum number of items not met.", e.getLocalizedMessage()); |
| } |
| |
| try { |
| s.getItems().validateOutput(split("1,2,3"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum number of items exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().validateOutput(split("1,2,3,4"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum number of items exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().validateOutput(split("1,2,3,4,5"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum number of items exceeded.", e.getLocalizedMessage()); |
| } |
| try { |
| s.getItems().getItems().getItems().getItems().validateOutput(split("1,2,3,4,5,6"), BeanContext.DEFAULT); |
| fail(); |
| } catch (SchemaValidationException e) { |
| assertEquals("Maximum number of items exceeded.", e.getLocalizedMessage()); |
| } |
| } |
| } |