/*
    * 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.cache;
  
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.is;
  import static org.hamcrest.Matchers.nullValue;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.verify;
  import static org.mockito.Mockito.when;
  import help.de.smartics.properties.core.PropertyDescriptorBuilder;
  import help.de.smartics.properties.core.PropertyKeyBuilder;
  
  import java.util.Properties;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.Test;
  
  import de.smartics.properties.api.config.domain.ConfigurationProperties;
  import de.smartics.properties.api.config.domain.DescribedProperty;
  import de.smartics.properties.api.config.domain.Property;
  import de.smartics.properties.api.config.domain.PropertyLocation;
  import de.smartics.properties.api.config.domain.ValidatedProperty;
  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.api.core.domain.PropertyDescriptor;
  import de.smartics.properties.api.core.domain.PropertyKey;
  import de.smartics.properties.impl.config.domain.key.rtaware.TenantId;
  import de.smartics.properties.impl.config.domain.key.rtaware.TenantUserConfigurationKey;
  import de.smartics.properties.impl.config.domain.key.rtaware.UserId;
  import de.smartics.properties.spi.config.cache.CacheManagerFactory;
  import de.smartics.testdoc.annotations.Uut;
  
  /**
   * Tests {@link DependencyTrackingCache}.
   */
  public class DependencyTrackingCacheTest
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    private static final PropertyLocation TEST_SOURCE = new PropertyLocation(
        "test");
  
    // ... values for caching tests
    private static final String KEY_MISS = "miss";
  
    private static final String KEY_HIT = "hit";
  
    private static final String VALUE_HIT = "hitValue";
  
    private static final String NO_DEFAULT = null;
  
    private static final String NO_VALUE = null;
  
    private static final String NO_DEFAULT_EXPRESSION = null;
  
    // ... values for tests on resolving place holder
  
    private static final String DOMAIN_KEY = "domain";
  
    private static final String DOMAIN_VALUE = "example.com";
  
    private static final String NEW_DOMAIN_VALUE = "new.example.com";
  
    private static final String SERVER_KEY = "server";
  
    private static final String SERVER_VALUE = "www.${domain}";
  
    private static final String RESOLVED_SERVER_VALUE = "www.example.com";
  
    private static final String NEW_RESOLVED_SERVER_VALUE = "www.new.example.com";
  
    private static final String MAIL_SERVER_KEY = "mail.server";
  
    private static final String MAIL_SERVER_VALUE = null;
  
    private static final String MAIL_SERVER_EXPRESSION = "mail-${server}";
  
    private static final String RESOLVED_MAIL_SERVER_VALUE =
        "mail-www.example.com";
  
   private static final String NEW_RESOLVED_MAIL_SERVER_VALUE =
       "mail-www.new.example.com";
 
   // --- members --------------------------------------------------------------
 
   @Uut
   private DependencyTrackingCache uut;
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- prepare --------------------------------------------------------------
 
   @Before
   public void setUp()
   {
     final ConfigurationKey<?> key =
         new TenantUserConfigurationKey(EnvironmentId.ANY_ENV,
             ApplicationId.ANY_APP, TenantId.ANY_TENANT, UserId.ANY_USER);
     uut = new DependencyTrackingCache(key);
   }
 
   @After
   public void shutDown()
   {
     CacheManagerFactory.getInstance().createManager().clearAll();
   }
 
   // --- helper ---------------------------------------------------------------
 
   private void initCache()
   {
     final ConfigurationProperties propertySource =
         mock(ConfigurationProperties.class);
 
     when(propertySource.getValidatedProperty(DOMAIN_KEY, null)).thenReturn(
         create(TEST_SOURCE, DOMAIN_KEY, DOMAIN_VALUE, NO_DEFAULT_EXPRESSION,
             DOMAIN_VALUE),
         create(TEST_SOURCE, DOMAIN_KEY, DOMAIN_VALUE, NO_DEFAULT_EXPRESSION,
             NEW_DOMAIN_VALUE));
     when(propertySource.getValidatedProperty(SERVER_KEY, null)).thenReturn(
         create(TEST_SOURCE, SERVER_KEY, SERVER_VALUE, NO_DEFAULT_EXPRESSION,
             RESOLVED_SERVER_VALUE),
         create(TEST_SOURCE, SERVER_KEY, SERVER_VALUE, NO_DEFAULT_EXPRESSION,
             NEW_RESOLVED_SERVER_VALUE));
     when(propertySource.getValidatedProperty(MAIL_SERVER_KEY, null))
         .thenReturn(
             create(TEST_SOURCE, MAIL_SERVER_KEY, MAIL_SERVER_VALUE,
                 MAIL_SERVER_EXPRESSION, RESOLVED_MAIL_SERVER_VALUE),
             create(TEST_SOURCE, MAIL_SERVER_KEY, null, MAIL_SERVER_EXPRESSION,
                 NEW_RESOLVED_MAIL_SERVER_VALUE));
 
     uut.getValidatedProperty(propertySource, createDescriptor(DOMAIN_KEY),
         NO_DEFAULT);
     uut.getValidatedProperty(propertySource, createDescriptor(SERVER_KEY),
         NO_DEFAULT);
     uut.getValidatedProperty(propertySource, createDescriptor(MAIL_SERVER_KEY),
         NO_DEFAULT);
   }
 
   private static ValidatedProperty create(final PropertyLocation source,
       final String name, final String value, final String expression,
       final Object validatedValue) throws IllegalArgumentException
   {
     final ConfigurationKey<?> configurationKey =
         new TenantUserConfigurationKey(EnvironmentId.ANY_ENV,
             ApplicationId.ANY_APP, TenantId.ANY_TENANT, UserId.ANY_USER);
     final PropertyDescriptor descriptor =
         PropertyDescriptorBuilder.defaultPropertyDescriptor();
 
     final Property property = new Property(source, name, value);
     final DescribedProperty descProperty =
         new DescribedProperty(configurationKey, descriptor, property);
     final ValidatedProperty validatedProperty =
         new ValidatedProperty(descProperty, expression, validatedValue);
     return validatedProperty;
   }
 
   // --- tests ----------------------------------------------------------------
 
   private static PropertyDescriptor createDescriptor(final String keyName)
   {
     final PropertyDescriptorBuilder builder = PropertyDescriptorBuilder.a();
     final PropertyKeyBuilder keyBuilder = PropertyKeyBuilder.a();
     keyBuilder.withName(keyName).withPropertySet(null);
     final PropertyKey key = keyBuilder.build();
     builder.with(key);
 
     return builder.build();
   }
 
   @Test
   public void storesAMissInTheCache()
   {
     final ConfigurationProperties propertySource =
         mock(ConfigurationProperties.class);
     final ValidatedProperty validatedProperty =
         create(TEST_SOURCE, KEY_MISS, NO_VALUE, NO_DEFAULT_EXPRESSION, null);
     when(propertySource.getValidatedProperty(KEY_MISS, NO_DEFAULT)).thenReturn(
         validatedProperty);
 
     final PropertyDescriptor descriptor = createDescriptor(KEY_MISS);
     final ValidatedProperty property =
         uut.getValidatedProperty(propertySource, descriptor, NO_DEFAULT);
     assertThat(property, is(validatedProperty));
 
     uut.getValidatedProperty(propertySource, descriptor, NO_DEFAULT);
 
   }
 
   @Test
   public void storesAHitInTheCache()
   {
     final ConfigurationProperties propertySource =
         mock(ConfigurationProperties.class);
     final ValidatedProperty validatedProperty =
         create(TEST_SOURCE, KEY_HIT, VALUE_HIT, NO_DEFAULT_EXPRESSION, null);
     when(propertySource.getValidatedProperty(KEY_HIT, NO_DEFAULT)).thenReturn(
         validatedProperty);
 
     final PropertyDescriptor descriptor = createDescriptor(KEY_HIT);
     final ValidatedProperty property =
         uut.getValidatedProperty(propertySource, descriptor, NO_DEFAULT);
     assertThat(property, is(validatedProperty));
 
     uut.getValidatedProperty(propertySource, descriptor, NO_DEFAULT);
 
     verify(propertySource, times(1)).getValidatedProperty(KEY_HIT, NO_DEFAULT);
   }
 
   @Test
   public void removesAValueFromTheCache()
   {
     final ConfigurationProperties propertySource =
         mock(ConfigurationProperties.class);
     final ValidatedProperty validatedProperty =
         create(TEST_SOURCE, KEY_HIT, VALUE_HIT, NO_DEFAULT_EXPRESSION, null);
     when(propertySource.getValidatedProperty(KEY_HIT, NO_DEFAULT)).thenReturn(
         validatedProperty);
     final PropertyDescriptor descriptor = createDescriptor(KEY_HIT);
     uut.getValidatedProperty(propertySource, descriptor, NO_DEFAULT);
 
     final Property property = uut.removeFromCache(KEY_HIT);
     assertThat(property, is((Property) validatedProperty));
 
   }
 
   @Test
   public void allowsToRemoveAValueFromTheCacheThatIsNotThereGracefully()
   {
     final Property property = uut.removeFromCache(KEY_HIT);
     assertThat(property, is(nullValue()));
   }
 
   @Test
   public void removedDependentPropertiesRoot()
   {
     initCache();
 
     uut.removeFromCache(DOMAIN_KEY);
   }
 
   @Test
   public void removedDependentPropertiesMiddle()
   {
     initCache();
 
     uut.removeFromCache(SERVER_KEY);
   }
 
   @Test
   public void removedDependentPropertiesLeaf()
   {
     initCache();
 
     uut.removeFromCache(MAIL_SERVER_KEY);
   }
 
   @Test
   public void removeMulipleRoot()
   {
     initCache();
 
     final Properties properties = new Properties();
     properties.setProperty(DOMAIN_KEY, DOMAIN_VALUE);
     properties.setProperty(MAIL_SERVER_KEY, "non-null");
 
     uut.removeFromCache(properties);
   }
 
   @Test
   public void removeMulipleMiddle()
   {
     initCache();
 
     final Properties properties = new Properties();
     properties.setProperty(SERVER_KEY, SERVER_VALUE);
 
     uut.removeFromCache(properties);
   }
 
   @Test
   public void removeMulipleLeaf()
   {
     initCache();
 
     final Properties properties = new Properties();
     properties.setProperty(SERVER_KEY, SERVER_VALUE);
     properties.setProperty(MAIL_SERVER_KEY, "non-null");
 
     uut.removeFromCache(properties);
   }
 
   @Test
   public void allowsEmptyPropertiesGracefully()
   {
     initCache();
 
     final Properties properties = new Properties();
 
     uut.removeFromCache(properties);
   }
 }