/*
    * 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.impl.config.domain.key.envapp;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  
  import java.util.Arrays;
  import java.util.List;
  
  import org.junit.Before;
  import org.junit.Test;
  
  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.testdoc.annotations.Uut;
  import de.smartics.util.lang.StaticAnalysis;
  
  /**
   * Tests {@link EnvAppKeyListBuilder}.
   */
  public class EnvAppKeyListBuilderTest
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    private static final String ENV_NAME = "test";
  
    private static final String NODEN_AME = "test-node";
  
    private static final String GROUP_ID = "test-group";
  
    private static final String ARTIFACT_ID = "test-artifact";
  
    private static final String VERSION = "1.0";
  
    // ... key parts ............................................................
  
    private static final EnvironmentId ENV_NAME_ONLY =
        new EnvironmentId(ENV_NAME);
  
    private static final EnvironmentId ENV_NAME_AND_NODE = new EnvironmentId(
        ENV_NAME, NODEN_AME);
  
    private static final ApplicationId APP_GROUP_ONLY = new ApplicationId(
        GROUP_ID, null, null);
  
    private static final ApplicationId APP_NO_VERSION = new ApplicationId(
        GROUP_ID, ARTIFACT_ID, null);
  
    private static final ApplicationId APP_ALL = new ApplicationId(GROUP_ID,
        ARTIFACT_ID, VERSION);
  
    // ... keys .................................................................
  
    private static final ConfigurationKey<?> ANY = new EnvAppConfigurationKey(
        EnvironmentId.ANY_ENV, ApplicationId.ANY_APP);
  
    private static final ConfigurationKey<?> E = new EnvAppConfigurationKey(
        ENV_NAME_ONLY, ApplicationId.ANY_APP);
  
    private static final ConfigurationKey<?> EN = new EnvAppConfigurationKey(
        ENV_NAME_AND_NODE, ApplicationId.ANY_APP);
  
    private static final ConfigurationKey<?> E_G = new EnvAppConfigurationKey(
        ENV_NAME_ONLY, APP_GROUP_ONLY);
  
    private static final ConfigurationKey<?> EN_G = new EnvAppConfigurationKey(
        ENV_NAME_AND_NODE, APP_GROUP_ONLY);
  
    private static final ConfigurationKey<?> E_GA = new EnvAppConfigurationKey(
        ENV_NAME_ONLY, APP_NO_VERSION);
  
    private static final ConfigurationKey<?> EN_GA = new EnvAppConfigurationKey(
        ENV_NAME_AND_NODE, APP_NO_VERSION);
  
    private static final ConfigurationKey<?> E_GAV = new EnvAppConfigurationKey(
        ENV_NAME_ONLY, APP_ALL);
  
    private static final ConfigurationKey<?> EN_GAV = new EnvAppConfigurationKey(
        ENV_NAME_AND_NODE, APP_ALL);
  
    private static final ConfigurationKey<?> ANY_G = new EnvAppConfigurationKey(
        EnvironmentId.ANY_ENV, APP_GROUP_ONLY);
 
   private static final ConfigurationKey<?> ANY_GA = new EnvAppConfigurationKey(
       EnvironmentId.ANY_ENV, APP_NO_VERSION);
 
   private static final ConfigurationKey<?> ANY_GAV =
       new EnvAppConfigurationKey(EnvironmentId.ANY_ENV, APP_ALL);
 
   // --- members --------------------------------------------------------------
 
   @Uut
   private EnvAppKeyListBuilder uut;
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- prepare --------------------------------------------------------------
 
   @Before
   public void setUp()
   {
     uut = new EnvAppKeyListBuilder();
   }
 
   // --- helper ---------------------------------------------------------------
 
   // --- tests ----------------------------------------------------------------
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithOnlyAnEnvironmentName()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(E);
 
     assertThat(keySet, is(Arrays.asList(E, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithEnvironmentNameAndNode()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(EN);
 
     assertThat(keySet, is(Arrays.asList(EN, E, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithFullEnvironmentNameOnlyAndGroup()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(E_G);
 
     assertThat(keySet, is(Arrays.asList(E_G, E, ANY_G, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithFullEnvironmentAndGroup()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(EN_G);
 
     assertThat(keySet, is(Arrays.asList(EN_G, EN, E, ANY_G, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithFullEnvironmentNameOnlyAndGA()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(E_GA);
 
     assertThat(keySet, is(Arrays.asList(E_GA, E_G, E, ANY_GA, ANY_G, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithFullEnvironmentAndGA()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(EN_GA);
 
     assertThat(keySet,
         is(Arrays.asList(EN_GA, EN_G, EN, E_G, E, ANY_GA, ANY_G, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithFullEnvironmentNameOnlyAndGAV()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(E_GAV);
 
     assertThat(keySet,
         is(Arrays.asList(E_GAV, E_GA, E_G, E, ANY_GAV, ANY_GA, ANY_G, ANY)));
   }
 
   @Test
   @SuppressWarnings(StaticAnalysis.UNCHECKED)
   public void derivesFromKeyWithFullEnvironmentAndGAV()
   {
     final List<ConfigurationKey<?>> keySet = uut.createKeyList(EN_GAV);
 
     assertThat(keySet, is(Arrays.asList(EN_GAV, EN_GA, EN_G, EN, E_GAV, E_GA,
         E_G, E, ANY_GAV, ANY_GA, ANY_G, ANY)));
   }
 }