/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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 de.smartics.properties.spi.core.constraint.jsr303;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Field;
  
  import javax.validation.constraints.Pattern;
  
  import org.hibernate.validator.constraints.CreditCardNumber;
  import org.hibernate.validator.constraints.Email;
  import org.hibernate.validator.constraints.Length;
  import org.hibernate.validator.constraints.NotBlank;
  import org.hibernate.validator.constraints.NotEmpty;
  import org.hibernate.validator.constraints.Range;
  import org.hibernate.validator.constraints.SafeHtml;
  import org.hibernate.validator.constraints.ScriptAssert;
  import org.hibernate.validator.constraints.URL;
  import org.junit.Test;
  
  import de.smartics.testdoc.annotations.Uut;
  
  /**
   * Tests {@link ConstraintPrettifier} with constraints from the package
   * <code>javax.validation.constraints</code>.
   */
  @Uut(type = ConstraintPrettifier.class)
  public class PrettifierHibernateTest
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Inner Classes *****************************
  
    @ScriptAssert(lang = "javascript", script = "test.js", alias = "alias")
    private static final class HibernateAnnotations
    {
      @CreditCardNumber
      String creditCardNumber;
  
      @Email(regexp = "\\d+")
      String noFlagEmail;
  
      @Email(regexp = "\\w+", flags = { Pattern.Flag.MULTILINE,
                                       Pattern.Flag.CASE_INSENSITIVE })
      String multiFlagEmail;
  
      @Email(regexp = "\\w+", flags = { Pattern.Flag.MULTILINE })
      String singleFlagEmail;
  
      @Length(min = -1 * 42, max = 42)
      String length;
  
      @NotBlank
      String notBlank;
  
      @NotEmpty
      String notEmpty;
  
      @Range(min = 2, max = 4)
      String range;
  
      @SafeHtml(additionalTags = { "tag1", "tag2" },
          whitelistType = SafeHtml.WhiteListType.BASIC)
      String safeHtml;
  
      @URL(flags = { Pattern.Flag.MULTILINE }, host = "example", port = 42,
          protocol = "https", regexp = "\\d+")
      String url;
    }
  
    // ********************************* Methods ********************************
  
    // --- prepare --------------------------------------------------------------
  
    // --- helper ---------------------------------------------------------------
  
    private static Annotation calcAnnotation(final String fieldName,
        final Class<? extends Annotation> annotationType)
   {
     try
     {
       final Field field =
           HibernateAnnotations.class.getDeclaredField(fieldName);
       return field.getAnnotation(annotationType);
     }
     catch (final Exception e)
     {
       throw new IllegalStateException("Cannot fetch annotation of type '"
                                       + annotationType + "' from field '"
                                       + fieldName + "'.");
     }
   }
 
   private static Annotation calcAnnotation(
       final Class<? extends Annotation> annotationType)
   {
     try
     {
       return HibernateAnnotations.class.getAnnotation(annotationType);
     }
     catch (final Exception e)
     {
       throw new IllegalStateException("Cannot fetch annotation of type '"
                                       + annotationType + "' from class '"
                                       + HibernateAnnotations.class.getName()
                                       + "'.");
     }
   }
 
   // --- tests ----------------------------------------------------------------
 
   @Test
   public void acceptsCreditCardNumber()
   {
     final Annotation annotation =
         calcAnnotation("creditCardNumber", CreditCardNumber.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("CreditCardNumber")));
   }
 
   @Test
   public void acceptsNoFlagEmail()
   {
     final Annotation annotation = calcAnnotation("noFlagEmail", Email.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Email(regexp=\\d+)")));
   }
 
   @Test
   public void acceptsMultiFlagEmail()
   {
     final Annotation annotation = calcAnnotation("multiFlagEmail", Email.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(),
         is(equalTo("Email(flags=[MULTILINE, CASE_INSENSITIVE], regexp=\\w+)")));
   }
 
   @Test
   public void acceptsSingleFlagEmail()
   {
     final Annotation annotation =
         calcAnnotation("singleFlagEmail", Email.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(),
         is(equalTo("Email(flags=[MULTILINE], regexp=\\w+)")));
   }
 
   @Test
   public void acceptsLength()
   {
     final Annotation annotation = calcAnnotation("length", Length.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Length(min=-42, max=42)")));
   }
 
   // ...
 
   @Test
   public void acceptsNotBlank()
   {
     final Annotation annotation = calcAnnotation("notBlank", NotBlank.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("NotBlank")));
   }
 
   @Test
   public void acceptsNotEmpty()
   {
     final Annotation annotation = calcAnnotation("notEmpty", NotEmpty.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("NotEmpty")));
   }
 
   @Test
   public void acceptsRange()
   {
     final Annotation annotation = calcAnnotation("range", Range.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(uut.toString(), is(equalTo("Range(min=2, max=4)")));
   }
 
   @Test
   public void acceptsSafeHtml()
   {
     final Annotation annotation = calcAnnotation("safeHtml", SafeHtml.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(
         uut.toString(),
         is(equalTo("SafeHtml(additionalTags=[tag1, tag2], whitelistType=BASIC)")));
   }
 
   @Test
   public void acceptsScriptAssert()
   {
     final Annotation annotation = calcAnnotation(ScriptAssert.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(
         uut.toString(),
         is(equalTo("ScriptAssert(alias=alias, lang=javascript, script=test.js)")));
   }
 
   @Test
   public void acceptsUrl()
   {
     final Annotation annotation = calcAnnotation("url", URL.class);
     final ConstraintPrettifier uut = new ConstraintPrettifier(annotation);
     assertThat(
         uut.toString(),
         is(equalTo("URL(port=42, protocol=https, host=example, flags=[MULTILINE], regexp=\\d+)")));
   }
 }