/*
    * 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.config.properties.support;
  
  import static help.de.smartics.properties.api.config.domain.ConfigurationPropertiesManagementBuilder.a;
  import static org.hamcrest.MatcherAssert.assertThat;
  import static org.hamcrest.Matchers.equalTo;
  import static org.hamcrest.Matchers.is;
  
  import java.net.URL;
  import java.util.Collection;
  
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.experimental.categories.Category;
  
  import de.smartics.properties.api.config.app.FactoryConfiguration;
  import de.smartics.properties.api.config.domain.CompoundConfigurationException;
  import de.smartics.properties.api.config.domain.ConfigurationException;
  import de.smartics.properties.api.config.domain.ConfigurationProperties;
  import de.smartics.properties.api.config.domain.ConfigurationPropertiesManagement;
  import de.smartics.properties.api.config.domain.ConfigurationRepositoryManagement;
  import de.smartics.properties.api.config.domain.PropertyProvider;
  import de.smartics.properties.api.config.domain.key.ConfigurationKey;
  import de.smartics.properties.api.core.domain.PropertyDescriptorRegistry;
  import de.smartics.properties.api.core.security.Base64PropertyValueSecurity;
  import de.smartics.properties.impl.config.properties.PropertiesConfigurationProperties;
  import de.smartics.properties.impl.config.properties.PropertiesConfigurationPropertiesFactory;
  import de.smartics.properties.resource.domain.ArtifactId;
  import de.smartics.properties.resource.domain.ArtifactRef;
  import de.smartics.properties.resource.repository.RepositoryException;
  import de.smartics.properties.spi.config.support.AbstractConfigurationPropertiesFactory;
  import de.smartics.properties.spi.config.support.ClassPathLoader;
  import de.smartics.properties.spi.config.support.ConfigurationPropertiesManagementFactory;
  import de.smartics.properties.spi.config.support.FactoryCache;
  import de.smartics.properties.spi.config.support.InMemoryConfigurationRepositoryManagement;
  import de.smartics.properties.test.domain.ValidConfigurationKey;
  import de.smartics.testdoc.annotations.Uut;
  import de.smartics.testdoc.categories.Technical;
  import de.smartics.util.lang.NullArgumentException;
  import example.de.smartics.properties.simple.SimpleTestProperties;
  
  /**
   * Tests {@link ClassPathLoader}.
   */
  @Uut(type = ClassPathLoader.class)
  public class ClassPathLoaderTest
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    private ClassPathLoader<PropertiesConfigurationProperties> uut;
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- prepare --------------------------------------------------------------
  
    // CHECKSTYLE:OFF
    @Before
    public void setUp()
    {
      final PropertiesConfigurationPropertiesFactory factory =
          new PropertiesConfigurationPropertiesFactory();
      final PropertyDescriptorRegistry registry = factory.getRegistry();
  
      final ConfigurationPropertiesManagementFactory dummy =
          new ConfigurationPropertiesManagementFactory()
          {
            private static final long serialVersionUID = 1L;
  
            @Override
            public String getId()
            {
              return null;
            }
  
            @Override
            public ConfigurationPropertiesManagement create(
                final ConfigurationKey<?> key)
            {
              return a().with(ValidConfigurationKey.KEY).with(registry)
                 .with(new Base64PropertyValueSecurity()).build();
           }
 
           @Override
           public FactoryConfiguration getFactoryConfiguration()
           {
             return null;
           }
 
           @Override
           public void addRootLocations(final Collection<URL> urls)
           {
           }
 
           @Override
           public void addRootLocations(final URL... urls)
           {
           }
 
           @Override
           public void addPropertyProviders(
               final Collection<PropertyProvider> providers)
           {
           }
 
           @Override
           public void addPropertyProviders(final PropertyProvider... providers)
           {
           }
 
           @Override
           public ConfigurationPropertiesManagement createManagement(
               final ConfigurationKey<?> key) throws NullPointerException,
             ConfigurationException
           {
             return null;
           }
 
           @Override
           public ConfigurationProperties createDefault()
             throws ConfigurationException
           {
             return null;
           }
 
           @Override
           public ConfigurationPropertiesManagement createDefaultManagement()
             throws ConfigurationException
           {
             return null;
           }
 
           @Override
           public Collection<ConfigurationKey<?>> getRegisteredConfigurationKeys()
           {
             return null;
           }
 
           @Override
           public PropertyDescriptorRegistry getRegistry()
           {
             return null;
           }
 
           @Override
           public Collection<ConfigurationKey<?>> materialize()
           {
             return null;
           }
 
           @Override
           public void release()
           {
           }
 
           @Override
           public ConfigurationPropertiesManagement remove(
               final ConfigurationKey<?> key) throws NullPointerException
           {
             return null;
           }
 
           @Override
           public String addRootUrls(ArtifactId artifactId)
             throws NullArgumentException, RepositoryException,
             CompoundConfigurationException
           {
             return null;
           }
 
           @Override
           public ArtifactRef getArtifactRef(String artifactId)
             throws NullPointerException
           {
             return null;
           }
         };
 
     final ConfigurationRepositoryManagement cache =
         new InMemoryConfigurationRepositoryManagement(registry, dummy);
     final FactoryCache<PropertiesConfigurationProperties> factoryCache =
         new FactoryCache<PropertiesConfigurationProperties>(cache, factory);
     uut =
         new ClassPathLoader<PropertiesConfigurationProperties>(factoryCache,
             true, false, new Base64PropertyValueSecurity());
   }
 
   // CHECKSTYLE:ON
 
   // --- helper ---------------------------------------------------------------
 
   // --- tests ----------------------------------------------------------------
 
   @Test
   public void readsPropertyDescriptorsAndDefinitionsFromTheClassPath()
   {
     final URL url = SimpleTestProperties.class.getClassLoader().getResource(""); // NOPMD
     uut.addRootUrl(url);
 
     final ConfigurationRepositoryManagement repo = uut.load();
     final ConfigurationKey<?> key = ValidConfigurationKey.KEY;
     final ConfigurationPropertiesManagement config =
         repo.getPropertiesManagementWithDefaults(key);
     final SimpleTestProperties properties =
         config.getProperties(SimpleTestProperties.class);
 
     final String value = properties.name();
     assertThat(value, is(equalTo("value")));
   }
 
   @Test
   @Category(Technical.class)
   public void allowsToPassInAClassToDeriveTheRootUrl()
   {
     uut.addRootUrl(SimpleTestProperties.class);
 
     final ConfigurationRepositoryManagement repo = uut.load();
     final ConfigurationKey<?> key = ValidConfigurationKey.KEY;
     final ConfigurationPropertiesManagement config =
         repo.getPropertiesManagementWithDefaults(key);
 
     final SimpleTestProperties properties =
         config.getProperties(SimpleTestProperties.class);
 
     final String value = properties.name();
     assertThat(value, is(equalTo("value")));
   }
 }