/*
    * 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.tutorial.property.expressions;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  
  import java.net.MalformedURLException;
  import java.net.URL;
  
  import org.junit.Before;
  import org.junit.Test;
  
  import de.smartics.projectdoc.annotations.DocCategory;
  import de.smartics.projectdoc.annotations.Document;
  import de.smartics.projectdoc.annotations.topic.DocSection;
  import de.smartics.properties.api.core.domain.PropertyKey;
  import de.smartics.properties.api.core.domain.ReadOnlyPropertyException;
  import de.smartics.properties.impl.config.classpath.ClasspathConfigurationProperties;
  import de.smartics.properties.impl.config.classpath.ClasspathConfigurationPropertiesFactory;
  
  /**
   * This tutorial introduces how to add expressions to the property declaration.
   * <p>
   * Expressions allow to declare default values and to construct property values
   * out of other property values.
   * </p>
   * {@insertCode source="ExpressionsProperties"}
   */
  @Document(title = "Property Expressions", sortKey = "basics0060")
  @DocCategory({ "basics" })
  // @DocTopic(path="basics", step="60")
  public class PropertyExpressionsTutorial
  {
    private ClasspathConfigurationProperties config; // NOPMD
  
    private ExpressionsProperties properties;
  
    private OverridingExpressionsProperties overriddenProperties;
  
    @Before
    public void setUp()
    {
      config = createConfiguration();
      properties = config.getProperties(ExpressionsProperties.class);
      overriddenProperties =
          config.getProperties(OverridingExpressionsProperties.class);
    }
  
    private static ClasspathConfigurationProperties createConfiguration()
    {
      final ClasspathConfigurationPropertiesFactory factory =
          new ClasspathConfigurationPropertiesFactory();
      final ClasspathConfigurationProperties config = factory.create();
  
      config.addClassPathProperties(ExpressionsProperties.class);
      config.addClassPathProperties(OverridingExpressionsProperties.class);
  
      return config;
    }
  
    /**
     * <p>
     * The property <code>host</code> defaults to <code>localhost</code>.
     * </p>
     * {@insertCode}
     */
    @Test
    @DocSection
    public void simpleStringValue()
    {
      final String host = properties.host();
      assertThat(host, is("localhost"));
    }
  
    // CHECKSTYLE:OFF
    /**
     * <p>
     * The property <code>port</code> defaults to <code>808</code>.
     * </p>
     * {@insertCode}
     */
    @Test
    @DocSection
    public void simpleIntValue()
    {
     final int port = properties.port();
     assertThat(port, is(8080));
   }
 
   // CHECKSTYLE:ON
 
   /**
    * <p>
    * The URL property of <code>homePageUrl</code> is per default constructed by
    * <code>host</code> and <code>port</code>.
    * </p>
    * {@insertCode}
    */
   @Test
   @DocSection
   public void composedUrlValue() throws MalformedURLException
   {
     final URL homePageUrl = properties.homePageUrl();
     final URL expected = new URL("http://localhost:8080/index.html");
     assertThat(homePageUrl, is(expected));
   }
 
   /**
    * <p>
    * If the default values of properties are overridden, the expressions take
    * the correct current value (as you would expect).
    * </p>
    * <p>
    * The properties definition is this:
    * </p>
    * {@insertCode file="OverridingExpressionsProperties.properties"}
    * <p>
    * Here is how we access the home page URL property:
    * </p>
    * {@insertCode}
    */
   @Test
   @DocSection
   public void overrideValues() throws MalformedURLException
   {
     final URL homePageUrl = overriddenProperties.homePageUrl();
     final URL expected = new URL("http://www.example.com:8081/index.html");
     assertThat(homePageUrl, is(expected));
   }
 
   /**
    * <p>
    * If the property is changed, the composed property also reflects the change
    * (as one would expect). But the property has to be marked as
    * {@link de.smartics.properties.api.core.annotations.AccessType#READ_WRITE}.
    * </p>
    * {@insertCode}
    * <p/>
    * <div class="note"> It would be more elegant and less error prone, if the
    * key is fetched from the property set as shown in the next example. </div>
    */
   @Test(expected = ReadOnlyPropertyException.class)
   @DocSection
   public void overrideValuesAtRuntimeFailsForReadOnlyProperties()
     throws MalformedURLException
   {
     final PropertyKey key =
         new PropertyKey("tutorial.property.override", "port");
     config.setProperty(key, "4242");
   }
 
   /**
    * <p>
    * So here is the example where we change a <i>read-write</i> property, using
    * a properties key.
    * </p>
    * {@insertCode}
    */
   @Test
   @DocSection
   public void overrideValuesAtRuntime() throws MalformedURLException
   {
     final PropertyKey key = overriddenProperties.hostPropertyKey();
     config.setProperty(key, "www.smartics.de");
     final URL homePageUrl = overriddenProperties.homePageUrl();
     final URL expected = new URL("http://www.smartics.de:8081/index.html");
     assertThat(homePageUrl, is(expected));
   }
 }