/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic 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.opensource.org/licenses/gpl-license.php
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the Gnu General Public License for more details.
   */
  package org.figure8.join.businessfacades.environment;
  
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.commons.Step;
  import org.figure8.join.businessobjects.commons.Release;
  import org.figure8.join.businessobjects.commons.persistence.StepDao;
  import org.figure8.join.businessobjects.commons.persistence.ReleaseDao;
  import org.figure8.join.businessobjects.environment.LogicalEnvironment;
  import org.figure8.join.businessobjects.environment.PhysicalEnvironment;
  import org.figure8.join.util.SpringTestCase;
  
  import java.util.Date;
  /**
   * JUnit test case for testing the EnvironmentManager implementation.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version Revision$
   */
  public class EnvironmentManagerTest extends SpringTestCase{
  
     // Static -------------------------------------------------------------------
  
     /** Spring configuration files */
     private String[] configLocations = new String[]{
        "classpath:/org/figure8/join/businessfacades/environment/spring.xml",
        "classpath:/org/figure8/join/businessobjects/environment/persistence/spring.xml"};
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The needed StepDao impl */
     protected StepDao stepDao = null;
     /** The needed ReleaseDao impl */
     protected ReleaseDao releaseDao = null;
  
     /** The EnvironmentManager implementation instance to test. */
     protected EnvironmentManager environmentManager = null;
  
  
     // Override of SpringTestCase -----------------------------------------------
  
     /** Retrieve the needed daos and managed after having initialized context */
     public void setUp(){
        super.setUp();
        // Get the needed daos ...
        stepDao = (StepDao)context.getBean("stepDao");
        releaseDao = (ReleaseDao)context.getBean("releaseDao");
        // ... and the required manager.
        environmentManager = (EnvironmentManager)context.getBean("environmentManager");
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** Test the logical environment related methods. */
     public void testLogicalEnvironments(){
        // Create required items for logical environment.
        Step step = new Step("first", 1);
        Release release = new Release("10.0", 10, 0, new Date());
        try{
           stepDao.save(step);
           releaseDao.save(release);
        }
        catch (Exception e){
           fail("No exception should be thrown");
        }
        // Save a bunch of logical environments.
        LogicalEnvironment env1 = new LogicalEnvironment("key1", "label1", "description1", "managerId", step, release);
        LogicalEnvironment env2 = new LogicalEnvironment("key2", "label2", "description2", "managerId", step, release);
        try{
           environmentManager.saveLogicalEnvironment(env1);
           environmentManager.saveLogicalEnvironment(env2);
        }
        catch (Exception e){
           fail("No exception should be thrown");
        }
        // Assert there's 2 logical environments created.
        assertEquals("Logical environments are successfully created", 2, environmentManager.getLogicalEnvironments().size());
  
        // Retrieve a logical environment by its key.
        LogicalEnvironment foundEnv = environmentManager.getLogicalEnvironment("key1");
        assertNotNull("Found a logical environment", foundEnv);
        assertEquals("Found the correct environment", "key1", foundEnv.getKey());
        assertEquals("Found the correct environment", "label1", foundEnv.getLabel());
        assertEquals("Found the correct environment", "description1", foundEnv.getDescription());
        assertEquals("Found the correct environment", "managerId", foundEnv.getManagerId());
 
       // Try creating a new environment with same key.
       boolean exception = false;
       LogicalEnvironment env3 = new LogicalEnvironment("key2", "label3", "description3", "managerId", step, release);
       try{
          environmentManager.saveLogicalEnvironment(env3);
       }
       catch (DuplicateEntityException dee){
          // Check exception.
          assertEquals("Original entity causes duplicate", "key2", ((LogicalEnvironment)dee.getOriginalEntity()).getKey());
          exception = true;
       }
       assertTrue("DuplicateEntityException was thrown", exception);
    }
 
    /** Test the physical environment related methods. */
    public void testPhysicalEnvironments(){
       // Save a bunch of new physical environments.
       PhysicalEnvironment env1 = new PhysicalEnvironment("key1", "name1");
       PhysicalEnvironment env2 = new PhysicalEnvironment("key2", "name2");
       try{
          environmentManager.savePhysicalEnvironment(env1);
          environmentManager.savePhysicalEnvironment(env2);
       }
       catch (Exception e){
          fail("No exception should be thrown");
       }
       // Assert there's 2 physical environemnts created.
       assertEquals("Physical environments are successfully created", 2, environmentManager.getPhysicalEnvironments().size());
 
       // Retrieve a physical environment by its key.
       PhysicalEnvironment foundEnv = environmentManager.getPhysicalEnvironment("key1");
       assertNotNull("Found a physical environment", foundEnv);
       assertEquals("Found the correct environment", "key1", foundEnv.getKey());
       assertEquals("Found the correct environment", "name1", foundEnv.getName());
 
       // Try creating a new enviroment with same key.
       boolean exception = false;
       PhysicalEnvironment env3 = new PhysicalEnvironment("key2", "name3");
       try{
          environmentManager.savePhysicalEnvironment(env3);
       }
       catch (DuplicateEntityException dee){
          // Check exception.
          assertEquals("Original entity causes duplicate", "key2", ((PhysicalEnvironment)dee.getOriginalEntity()).getKey());
          exception = true;
       }
       assertTrue("DuplicateEntityException was thrown", exception);
    }
 
 
    // Implementation of SpringTestCase -----------------------------------------
 
    /** @return An array of Spring config file locations. */
    public String[] getConfigLocations(){
       return configLocations;
    }
 }