@Valid(value = INT, legal = "30") Call<Integer> integer(); }
/** * Validate {@code candidate} based on the regex pattern supplied. */ @Override public void validate(Metadata<Valid> metadata, Object candidate) throws AssertionError { Valid valid = metadata.getAnnotation(); String regex = valid.value(); String input = String.valueOf(candidate); if (!input.matches(regex)) throw new AssertionError(errorMessage(input,regex)); }
/** * Return as legal value the generated value from the regex pattern supplied. */ @Override public Object legal(Metadata<Valid> metadata) { Valid valid = metadata.getAnnotation(); String defaultLegal = valid.legal(); if (!defaultLegal.isEmpty()) { return safetyCast.with(defaultLegal, metadata.getType()); } String regex = valid.value(); String result = new Generex(regex).random(); result = result.replace("^", "") .replace("$", "") .replace("?", ""); if (regex.equals(Valid.Template.ID)) { if (result.length() > 1 && result.charAt(0) == '0') { result = result.replaceFirst("0", ""); } } if (regex.equals(Valid.Template.INT) || regex.equals(Valid.Template.ID) || regex.equals(Valid.Template.NUMBER)) { if (result.length() > 8) { result = result.substring(0, 7); } } return safetyCast.with(result, metadata.getType()); }
/** * Return empty if type is string, otherwise return 0. */ @Override public Object illegal(Metadata<Valid> metadata) { String defaultOptional = metadata.getAnnotation().illegal(); Type type = metadata.getType(); if (!defaultOptional.isEmpty()) { return safetyCast.with(defaultOptional, metadata.getType()); } else if (type.equals(String.class)) { return safetyCast.with("", type); } else { return safetyCast.with(0, type); } }
void string(@Valid(STRING) String string); void stringWithDefault(@Valid(value = STRING, legal = "74hrun") String string);
@Theory @Test public void When_Not_Pass_Validation_Then_Throw_Assertion_Error(Data data) throws NoSuchMethodException { String methodName = data.methodName; Method method = Providers.class.getDeclaredMethod(methodName, data.classParam); Valid annotation = (Valid) method.getParameterAnnotations()[0][0]; Type type = method.getGenericParameterTypes()[0]; Metadata<Valid> metadata = new Metadata<>(Providers.class, method, null, annotation, type); for (Object illegal : data.illegal) { try { validMockery.validate(metadata, illegal); fail(); } catch (AssertionError e) { String expectedMessage = validMockery.errorMessage(String.valueOf(illegal), metadata.getAnnotation().value()); assertThat(expectedMessage, is(e.getMessage())); } } }
@Valid(value = INT, legal = "30") Observable<Integer> integer();
@Valid(STRING) Object notSupportedTypeMethod();
@Valid(STRING) List<String> method(); }
@Valid(Valid.Template.STRING) List<String> method2(); }
@Valid(STRING) List<String> method(); }
void phone(@Valid(PHONE) String phone); void phoneWithDefault(@Valid(value = PHONE, legal = "9653425132") String phone);
@Valid(STRING) String oneMockeryMethod();
void number(@Valid(NUMBER) double number); void numberWithDefault(@Valid(value = NUMBER, legal = "1.34") double number);
void url(@Valid(URL) String url); void urlWithDefault(@Valid(value = URL, legal = "http://foo.com/blah_blah") String url);
@Valid(STRING) Object notSupportedTypeMethod();