/*
    * 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.config.key;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  
  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.DocChapter;
  import de.smartics.projectdoc.annotations.topic.DocSection;
  import de.smartics.properties.api.config.app.ConfigurationPropertiesFactory;
  import de.smartics.properties.api.config.app.ConfigurationPropertiesFactoryFactory;
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.key.ApplicationId;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.config.domain.key.EnvironmentId;
  import de.smartics.properties.impl.config.domain.key.rtaware.TenantUserConfigurationKey;
  import de.smartics.sandbox.mail.AnnouncementProperties;
  import de.smartics.sandbox.mail.MailProperties;
  
  /**
   * This tutorial shows how configurations for one environment with multiple
   * nodes can be bundled. This may not be for everyone's taste since it implies
   * that configurations not required by one node are nonetheless deployed. If you
   * like to deploy only configurations specific to one node, you simply have to
   * provide one project / artifact per node.
   */
  @Document(title = "Multiple Nodes", sortKey = "basics1010")
  @DocCategory({ "basics" })
  // @DocPrerequisites(ConfigurationKeyTutorial.class)
  // @DocTopic(path="basics", step="1010")
  public class MultiConfigurationKeyTutorial
  {
    private ConfigurationPropertiesFactory factory;
  
    @Before
    public void setUp()
    {
      factory = ConfigurationPropertiesFactoryFactory.createDefaultFactory();
    }
  
    /**
     * <p>
     * In this example we assume that the <code>test-module-announce</code> module
     * is deployed on the main server while <code>test-module-mail</code> is part
     * of a mail server. Both servers are part of the same environment and
     * deployed to their own nodes.
     * </p>
     * <p>
     * We simulate the two nodes in one project. In real life both will have their
     * own projects and use only one of the following dependencies:
     * </p>
     *
     * <pre>
     *     <dependency>
     *       <groupId>de.smartics.sandbox</groupId>
     *       <artifactId>test-module-mail</artifactId>
     *     </dependency>
     *     <dependency>
     *       <groupId>de.smartics.sandbox</groupId>
     *       <artifactId>test-module-announce</artifactId>
     *     </dependency>
     * </pre>
     * <p>
     * The definition for these properties is provided by a dependency like this:
     * </p>
     *
     * <pre>
     *     <dependency>
     *       <groupId>de.smartics.sandbox</groupId>
     *       <artifactId>test-application-config-multinode</artifactId>
     *     </dependency>
     * </pre>
     * <p>
     * Now let's have a look how we can access information on the two nodes.
     * </p>
     */
    @DocChapter
    public void accessConfigurationByHardcodedKey()
    {
    }
  
   /**
    * <p>
    * Basically access information is purely a matter of creating the correct
    * configuration key. This key identifies the application and the factory
    * provides access to this information.
    * </p>
    * {@insertCode}
    * <p>
    * In {@$1}
    * </p>
    */
   @DocSection
   @Test
   public void theMailServerConfiguration()
   {
     final ConfigurationKey<?> key =
         new TenantUserConfigurationKey(new EnvironmentId("test", "mail"),
             new ApplicationId("de.smartics.sandbox", "mail-server", "1.0")); // {1}
 
     final ConfigurationPropertiesManagement config =
         factory.createManagement(key); // {2}
 
     final MailProperties properties =
         config.getProperties(MailProperties.class); // {3}
 
     final int mailsPerPage = properties.mailsPerPage(); // {4}
     assertThat(mailsPerPage, is(10)); // {5}
   }
 
   /**
    * <p>
    * The main server simply changes the name of the node and the name of the
    * application. This would allow the same application be deployed on multiple
    * nodes. Note that a node is not required to be a physical instance. A node
    * may refer to an EAR deployable that is deployed side by side to other EARs
    * on the same application server.
    * </p>
    * {@insertCode}
    * <p>
    * In {@$1}
    * </p>
    */
   @DocSection
   @Test
   public void theMainServerConfiguration()
   {
     final ConfigurationKey<?> key =
         new TenantUserConfigurationKey(new EnvironmentId("test", "main"),
             new ApplicationId("de.smartics.sandbox", "app-server", "1.0")); // {1}
     final ConfigurationPropertiesManagement config =
         factory.createManagement(key); // {2}
 
     final AnnouncementProperties properties =
         config.getProperties(AnnouncementProperties.class); // {3}
 
     final int lookup = properties.lookupIntervalMs(); // {4}
     assertThat(lookup, is(0)); // {5}
   }
 }