/*
    * 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 test.de.smartics.properties.spi.core.metadata;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.nullValue;
  
  import java.lang.reflect.Method;
  import java.util.Arrays;
  
  import org.junit.Test;
  
  import de.smartics.projectdoc.annotations.DocCategory;
  import de.smartics.projectdoc.annotations.DocParent;
  import de.smartics.projectdoc.annotations.DocTag;
  import de.smartics.projectdoc.annotations.Document;
  import de.smartics.properties.api.core.domain.DocumentMetaData;
  import de.smartics.properties.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.spi.core.metadata.PropertyMetaDataParser;
  import de.smartics.testdoc.annotations.Uut;
  
  /**
   * Tests {@link de.smartics.properties.spi.core.metadata.PropertyMetaDataParser} with
   * projectdoc annotations.
   */
  @Uut(type = PropertyMetaDataParser.class)
  public class PropertyMetaDataParserDocumentAnnotationsTest extends
      AbstractPropertyMetaDataParserTestBase
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    public static final String PARENT_NAME = "Parent Name";
  
    public static final String PARENT_TITLE = "Parent Title";
  
    public static final String PARENT_PARENT_DOCUMENT = "Parent Parent Document";
  
    public static final String PARENT_SPACE = "Parent Space";
  
    public static final String PARENT_AUDIENCE_1 = "Parent Audience 1";
  
    public static final String PARENT_AUDIENCE_2 = "Parent Audience 2";
  
    public static final String PARENT_CATEGORY = "parentCategory";
  
    public static final String PARENT_TAG = "parentTag";
  
    // --- members --------------------------------------------------------------
  
    // ****************************** Inner Classes *****************************
  
    @DocParent({ PARENT_PARENT_DOCUMENT })
    @Document(name = PARENT_NAME, shortDescription = "Parent Short Description.",
        notes = { "Parent Note 1", "Parent Note 2" }, space = PARENT_SPACE,
        title = "Parent Title", sortKey = "Parent Sort Key",
        summary = "Parent Summary", audience = { PARENT_AUDIENCE_1,
                                                PARENT_AUDIENCE_2 })
    @DocCategory({ PARENT_CATEGORY })
    @DocTag(PARENT_TAG)
    public interface TestProperties
    {
      String inheritAll();
  
      @DocParent({ "Child 1 Parent" })
      @Document(name = "Child Name 1",
          shortDescription = "Child 1 Short Description.",
          notes = { "Child 1 Notes" }, space = "Child 1 Space",
          title = "Child 1 Title", sortKey = "Child 1 Sort Key",
          summary = "Child 1 Summary", audience = "Child 1 Audience")
      @DocCategory({ "Child 1 Category" })
      @DocTag({ "Child 1 Tag" })
      String oneValue();
  
      @DocParent({ "Child 2 Parent 1", "Child 2 Parent 2" })
      @Document(audience = { "Child 2 Audience 1", "Child 2 Audience 2" })
      @DocCategory({ "Child 2 Category 1", "Child 2 Category 2" })
      @DocTag({ "Child 2 Tag 1", "Child 2 Tag 2" })
      String multipleValues();
    }
  
    // ********************************* Methods ********************************
  
   // --- prepare --------------------------------------------------------------
 
   // --- helper ---------------------------------------------------------------
 
   private DocumentMetaData runTest(final String methodNameAndPropertyName)
   {
     final Method method =
         fetchMethod(TestProperties.class, methodNameAndPropertyName);
     final PropertyDescriptor descriptor = uut.readDescriptor(method);
     final DocumentMetaData metaData = descriptor.getDocumentMetaData();
     return metaData;
   }
 
   // --- tests ----------------------------------------------------------------
 
   @Test
   public void propertyMetaDataAnnotationIsNotRequired()
   {
     final DocumentMetaData metaData = runTest("inheritAll");
 
     assertThat(metaData.getParents().isEmpty(), is(true));
     assertThat(metaData.getName(), is(PARENT_NAME + ".inheritAll"));
     assertThat(metaData.getShortDescription(), is(nullValue()));
     assertThat(metaData.getNotes().isEmpty(), is(true));
     assertThat(metaData.getSpace(), is(equalTo(PARENT_SPACE)));
     assertThat(metaData.getTitle(), is(PARENT_TITLE + ".inheritAll"));
     assertThat(metaData.getSortKey(), is(nullValue()));
     assertThat(metaData.getSummary(), is(nullValue()));
     assertThat(metaData.getAudience(),
         is(equalTo(Arrays.asList(PARENT_AUDIENCE_1, PARENT_AUDIENCE_2))));
     assertThat(metaData.getCategories(),
         is(equalTo(Arrays.asList(PARENT_CATEGORY))));
     assertThat(metaData.getTags(), is(equalTo(Arrays.asList(PARENT_TAG))));
   }
 
   @Test
   public void propertyMetaDataAnnotationProvidesDefaults()
   {
     final DocumentMetaData metaData = runTest("oneValue");
 
     assertThat(metaData.getParents(),
         is(equalTo(Arrays.asList("Child 1 Parent"))));
     assertThat(metaData.getName(), is(equalTo("Child Name 1")));
     assertThat(metaData.getShortDescription(),
         is(equalTo("Child 1 Short Description.")));
     assertThat(metaData.getNotes(), is(equalTo(Arrays.asList("Child 1 Notes"))));
     assertThat(metaData.getSpace(), is(equalTo("Child 1 Space")));
     assertThat(metaData.getTitle(), is(equalTo("Child 1 Title")));
     assertThat(metaData.getSortKey(), is(equalTo("Child 1 Sort Key")));
     assertThat(metaData.getSummary(), is(equalTo("Child 1 Summary")));
     assertThat(metaData.getAudience(), is(equalTo(Arrays.asList(
         PARENT_AUDIENCE_1, PARENT_AUDIENCE_2, "Child 1 Audience"))));
     assertThat(metaData.getCategories(),
         is(equalTo(Arrays.asList(PARENT_CATEGORY, "Child 1 Category"))));
     assertThat(metaData.getTags(),
         is(equalTo(Arrays.asList(PARENT_TAG, "Child 1 Tag"))));
   }
 
   @Test
   public void propertyMetaDataAnnotationAllowsMultipleValues()
   {
     final DocumentMetaData metaData = runTest("multipleValues");
 
     assertThat(metaData.getParents(),
         is(equalTo(Arrays.asList("Child 2 Parent 1", "Child 2 Parent 2"))));
     assertThat(metaData.getName(), is(PARENT_NAME + ".multipleValues"));
     assertThat(metaData.getShortDescription(), is(nullValue()));
     assertThat(metaData.getNotes().isEmpty(), is(true));
     assertThat(metaData.getSpace(), is(equalTo(PARENT_SPACE)));
     assertThat(metaData.getTitle(), is(PARENT_TITLE + ".multipleValues"));
     assertThat(metaData.getSortKey(), is(nullValue()));
     assertThat(metaData.getSummary(), is(nullValue()));
     assertThat(metaData.getAudience(), is(equalTo(Arrays.asList(
         PARENT_AUDIENCE_1, PARENT_AUDIENCE_2, "Child 2 Audience 1",
         "Child 2 Audience 2"))));
     assertThat(metaData.getCategories(), is(equalTo(Arrays.asList(
         PARENT_CATEGORY, "Child 2 Category 1", "Child 2 Category 2"))));
     assertThat(
         metaData.getTags(),
         is(equalTo(Arrays.asList(PARENT_TAG, "Child 2 Tag 1", "Child 2 Tag 2"))));
   }
 }