001/* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017package org.apache.juneau.rest.server.assertions; 018 019import java.io.*; 020import java.lang.reflect.*; 021import java.util.*; 022import java.util.function.*; 023import java.util.regex.*; 024 025import org.apache.juneau.commons.function.*; 026import org.apache.juneau.http.response.*; 027import org.apache.juneau.rest.server.httppart.*; 028import org.apache.juneau.bct.assertions.*; 029 030/** 031 * Used for fluent assertion calls against {@link RequestFormParam} objects. 032 * 033 * <h2 class='topic'>Test Methods</h2> 034 * <ul class='javatree'> 035 * <li class='jc'>{@link FluentStringAssertion} 036 * <ul class='javatreec'> 037 * <li class='jm'>{@link FluentStringAssertion#is(String) is(String)} 038 * <li class='jm'>{@link FluentStringAssertion#isNot(String) isNot(String)} 039 * <li class='jm'>{@link FluentStringAssertion#isLines(String...) isLines(String...)} 040 * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...) isSortedLines(String...)} 041 * <li class='jm'>{@link FluentStringAssertion#isIc(String) isIc(String)} 042 * <li class='jm'>{@link FluentStringAssertion#isNotIc(String) isNotIc(String)} 043 * <li class='jm'>{@link FluentStringAssertion#isContains(String...) isContains(String...)} 044 * <li class='jm'>{@link FluentStringAssertion#isNotContains(String...) isNotContains(String...)} 045 * <li class='jm'>{@link FluentStringAssertion#isEmpty() isEmpty()} 046 * <li class='jm'>{@link FluentStringAssertion#isNotEmpty() isNotEmpty()} 047 * <li class='jm'>{@link FluentStringAssertion#isString(Object) isString(Object)} 048 * <li class='jm'>{@link FluentStringAssertion#isMatches(String) isMatches(String)} 049 * <li class='jm'>{@link FluentStringAssertion#isPattern(String) isPattern(String)} 050 * <li class='jm'>{@link FluentStringAssertion#isPattern(String,int) isPattern(String,int)} 051 * <li class='jm'>{@link FluentStringAssertion#isPattern(Pattern) isPattern(Pattern)} 052 * <li class='jm'>{@link FluentStringAssertion#isStartsWith(String) isStartsWith(String)} 053 * <li class='jm'>{@link FluentStringAssertion#isEndsWith(String) isEndsWith(String)} 054 * </ul> 055 * <li class='jc'>{@link FluentObjectAssertion} 056 * <ul class='javatreec'> 057 * <li class='jm'>{@link FluentObjectAssertion#isExists() isExists()} 058 * <li class='jm'>{@link FluentObjectAssertion#is(Object) is(Object)} 059 * <li class='jm'>{@link FluentObjectAssertion#is(Predicate) is(Predicate)} 060 * <li class='jm'>{@link FluentObjectAssertion#isNot(Object) isNot(Object)} 061 * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...) isAny(Object...)} 062 * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...) isNotAny(Object...)} 063 * <li class='jm'>{@link FluentObjectAssertion#isNull() isNull()} 064 * <li class='jm'>{@link FluentObjectAssertion#isNotNull() isNotNull()} 065 * <li class='jm'>{@link FluentObjectAssertion#isString(String) isString(String)} 066 * <li class='jm'>{@link FluentObjectAssertion#isSame(Object) isSame(Object)} 067 * <li class='jm'>{@link FluentObjectAssertion#isType(Class) isType(Class)} 068 * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class) isExactType(Class)} 069 * </ul> 070 * </ul> 071 * 072 * <h2 class='topic'>Transform Methods</h2> 073 * <ul class='javatree'> 074 * <li class='jc'>{@link FluentRequestFormParamAssertion} 075 * <ul class='javatreec'> 076 * <li class='jm'>{@link FluentRequestFormParamAssertion#asBoolean() asBoolean()} 077 * <li class='jm'>{@link FluentRequestFormParamAssertion#asInteger() asInteger()} 078 * <li class='jm'>{@link FluentRequestFormParamAssertion#asLong() asLong()} 079 * <li class='jm'>{@link FluentRequestFormParamAssertion#asZonedDateTime() asZonedDateTime()} 080 * <li class='jm'>{@link FluentRequestFormParamAssertion#as(Class) as(Class)} 081 * <li class='jm'>{@link FluentRequestFormParamAssertion#as(Type,Type...) as(Type,Type...)} 082 * </ul> 083 * <li class='jc'>{@link FluentStringAssertion} 084 * <ul class='javatreec'> 085 * <li class='jm'>{@link FluentStringAssertion#asReplaceAll(String,String) asReplaceAll(String,String)} 086 * <li class='jm'>{@link FluentStringAssertion#asReplace(String,String) asReplace(String,String)} 087 * <li class='jm'>{@link FluentStringAssertion#asUrlDecode() asUrlDecode()} 088 * <li class='jm'>{@link FluentStringAssertion#asLc() asLc()} 089 * <li class='jm'>{@link FluentStringAssertion#asUc() asUc()} 090 * <li class='jm'>{@link FluentStringAssertion#asLines() asLines()} 091 * <li class='jm'>{@link FluentStringAssertion#asSplit(String) asSplit(String)} 092 * <li class='jm'>{@link FluentStringAssertion#asLength() asLength()} 093 * <li class='jm'>{@link FluentStringAssertion#asOneLine() asOneLine()} 094 * </ul> 095 * <li class='jc'>{@link FluentObjectAssertion} 096 * <ul class='javatreec'> 097 * <li class='jm'>{@link FluentObjectAssertion#asString() asString()} 098 * <li class='jm'>{@link FluentObjectAssertion#asString(ThrowingFunction) asString(ThrowingFunction)} 099 * <li class='jm'>{@link FluentObjectAssertion#asTransformed(UnaryOperator) asTransformed(UnaryOperator)} 100 * <li class='jm'>{@link FluentObjectAssertion#asAny() asAny()} 101 * </ul> 102 * </ul> 103 * 104 * <h2 class='topic'>Configuration Methods</h2> 105 * <ul class='javatree'> 106 * <li class='jc'>{@link Assertion} 107 * <ul class='javatreec'> 108 * <li class='jm'>{@link Assertion#setMsg(String, Object...) setMsg(String, Object...)} 109 * <li class='jm'>{@link Assertion#setOut(PrintStream) setOut(PrintStream)} 110 * <li class='jm'>{@link Assertion#setSilent() setSilent()} 111 * <li class='jm'>{@link Assertion#setStdOut() setStdOut()} 112 * <li class='jm'>{@link Assertion#setThrowable(Class) setThrowable(Class)} 113 * </ul> 114 * </ul> 115 * 116 * <h2 class='section'>See Also:</h2><ul> 117 * <li class='link'><a class="doclink" href="https://juneau.apache.org/docs/topics/JuneauEcosystemOverview">Juneau Ecosystem</a> 118 * </ul> 119 * 120 * @param <R> The return type. 121 */ 122public class FluentRequestFormParamAssertion<R> extends FluentStringAssertion<R> { 123 124 private final RequestFormParam value; 125 126 /** 127 * Chained constructor. 128 * 129 * <p> 130 * Used when transforming one assertion into another so that the assertion config can be used by the new assertion. 131 * 132 * @param creator 133 * The assertion that created this assertion. 134 * <br>Should be <jk>null</jk> if this is the top-level assertion. 135 * @param value 136 * The object being tested. 137 * <br>Can be <jk>null</jk>, in which case this assertion behaves as if testing a part with no value (e.g. {@link #isNull()} passes, transform methods yield <jk>null</jk>-valued assertions). 138 * @param returns 139 * The object to return after a test method is called. 140 * <br>If <jk>null</jk>, the test method returns this object allowing multiple test method calls to be 141 * used on the same assertion. 142 */ 143 public FluentRequestFormParamAssertion(Assertion creator, RequestFormParam value, R returns) { 144 super(creator, value == null ? null : value.asString().orElse(null), returns); 145 this.value = value; 146 setThrowable(BadRequest.class); 147 } 148 149 /** 150 * Constructor. 151 * 152 * @param value 153 * The object being tested. 154 * <br>Can be <jk>null</jk>, in which case this assertion behaves as if testing a part with no value (e.g. {@link #isNull()} passes, transform methods yield <jk>null</jk>-valued assertions). 155 * @param returns 156 * The object to return after a test method is called. 157 * <br>If <jk>null</jk>, the test method returns this object allowing multiple test method calls to be 158 * used on the same assertion. 159 */ 160 public FluentRequestFormParamAssertion(RequestFormParam value, R returns) { 161 this(null, value, returns); 162 } 163 164 /** 165 * Converts the parameter value to a type using {@link RequestFormParam#as(Class)} and then returns the value as an any-object assertion. 166 * 167 * @param <T> The object type to create. 168 * @param type The object type to create. 169 * @return A new fluent assertion object. 170 */ 171 public <T> FluentAnyAssertion<T,R> as(Class<T> type) { 172 return new FluentAnyAssertion<>(value == null ? null : value.as(type).orElse(null), returns()); 173 } 174 175 /** 176 * Converts the parameter value to a type using {@link RequestFormParam#as(Type,Type...)} and then returns the value as an any-object assertion. 177 * 178 * <p> 179 * See <a class="doclink" href="https://juneau.apache.org/docs/topics/ComplexDataTypes">Complex Data Types</a> for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}. 180 * 181 * @param type The object type to create. 182 * @param args Optional type arguments. 183 * @return A new fluent assertion object. 184 */ 185 public FluentAnyAssertion<Object,R> as(Type type, Type...args) { 186 return new FluentAnyAssertion<>(value == null ? null : value.as(type, args).orElse(null), returns()); 187 } 188 189 /** 190 * Converts this object assertion into a boolean assertion. 191 * 192 * @return A new assertion. 193 * @throws AssertionError If object is not a boolean. 194 */ 195 public FluentBooleanAssertion<R> asBoolean() { 196 return new FluentBooleanAssertion<>(this, value == null ? null : value.asBoolean().orElse(null), returns()); 197 } 198 199 /** 200 * Converts this object assertion into an integer assertion. 201 * 202 * @return A new assertion. 203 * @throws AssertionError If object is not an integer. 204 */ 205 public FluentIntegerAssertion<R> asInteger() { 206 return new FluentIntegerAssertion<>(this, value == null ? null : value.asInteger().orElse(null), returns()); 207 } 208 209 @Override /* Overridden from FluentStringAssertion */ 210 public FluentRequestFormParamAssertion<R> asJavaStrings() { 211 super.asJavaStrings(); 212 return this; 213 } 214 215 /** 216 * Converts this object assertion into a long assertion. 217 * 218 * @return A new assertion. 219 * @throws AssertionError If object is not a long. 220 */ 221 public FluentLongAssertion<R> asLong() { 222 return new FluentLongAssertion<>(this, value == null ? null : value.asLong().orElse(null), returns()); 223 } 224 225 /** 226 * Converts this object assertion into a zoned-datetime assertion. 227 * 228 * @return A new assertion. 229 * @throws AssertionError If object is not a zoned-datetime. 230 */ 231 public FluentZonedDateTimeAssertion<R> asZonedDateTime() { 232 return new FluentZonedDateTimeAssertion<>(this, value == null ? null : value.asDatePart().asZonedDateTime().orElse(null), returns()); 233 } 234 235 @Override /* Overridden from Assertion */ 236 public FluentRequestFormParamAssertion<R> setMsg(String msg, Object...args) { 237 super.setMsg(msg, args); 238 return this; 239 } 240 241 @Override /* Overridden from Assertion */ 242 public FluentRequestFormParamAssertion<R> setOut(PrintStream value) { 243 super.setOut(value); 244 return this; 245 } 246 247 @Override /* Overridden from Assertion */ 248 public FluentRequestFormParamAssertion<R> setSilent() { 249 super.setSilent(); 250 return this; 251 } 252 253 @Override /* Overridden from Assertion */ 254 public FluentRequestFormParamAssertion<R> setStdOut() { 255 super.setStdOut(); 256 return this; 257 } 258 259 @Override /* Overridden from Assertion */ 260 public FluentRequestFormParamAssertion<R> setThrowable(Class<? extends RuntimeException> value) { 261 super.setThrowable(value); 262 return this; 263 } 264}