/**
    * 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.services.repository;
  
  import org.figure8.join.businessobjects.commons.Release;
  import org.figure8.join.businessobjects.artifact.Deliverable;
  import org.figure8.join.businessobjects.artifact.DeliverableType;
  
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestSuite;
  
  import java.io.File;
  import java.io.FileWriter;
  import java.io.FileReader;
  import java.io.BufferedReader;
  import java.util.Date;
  /**
   * JUnit test case for testing the repository implementation based on Jakarta VFS.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision$
   */
  public class VFSRepositoryTest extends TestCase{
  
     // Attributes ---------------------------------------------------------------
  
     /** The root directory for VFS repository. */
     private File rootDir = null;
     /** The VFS repository to test. */
     private VFSRepository repository = null;
  
     /** Our test artifact. */
     private Deliverable artifact = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Default constructor. Build a test case using a name. */
     public VFSRepositoryTest(String testName){
        super(testName);
     }
  
  
     // Override of TestCase -----------------------------------------------------
  
     /**
      * Make this class a TestSuite.
      * @return A TestSuite containing this TestCase.
      */
     public static Test suite(){
        TestSuite suite = new TestSuite(VFSRepositoryTest.class);
        return suite;
     }
     
     
     // Public -------------------------------------------------------------------
  
     /** Setup the test fixtures */
     public void setUp() throws Exception{
        super.setUp();
        // Get user personnal directory.
        String userDir = System.getProperty("user.dir");
        rootDir = new File(userDir, "join-repository-test");
        rootDir.mkdir();
  
        // Create a VFS repository.
        repository = new VFSRepository();
  
        // Create an artifact (ie : a deliverable).
        Release release = new Release("1.0", 1, 0, new Date());
        DeliverableType type = new DeliverableType("mytype", "My Type Label", "mytype-r{0}-v{1}", false, false);
        artifact = new Deliverable("01", "comments", "supplierId", release, type);
     }
  
     /** Test the storage of an artifact within file repository */
     public void testStoreArtifactOnFile(){
        // Create a simple file for artifact content.
        File artifactFile = new File(rootDir, "vfsartifact.txt");
        try {writeToFile(artifactFile, "Test content");}
        catch (Exception e){
           fail("Exception while creating the artifact file");
        }
        // Store artifact within repository using different structures.
        repository.setBaseUrl("file://" + rootDir.getPath());
        repository.setStructureDefinition("${release}/${versionInfo}");
        try {repository.storeArtifact(artifact, artifactFile);}
        catch (Exception e){
          fail("Exception while storing artifact within repository");
       }
       File targetFile = new File(rootDir + "/1.0/01/mytype-r1.0-v01.txt");
       assertTrue("Artifact is in repository", targetFile.isFile());
       assertTrue("Artifact has correct content", compareFileContent(artifactFile, targetFile));
    }
 
    /** Test the storage of an artifact within ftp repository */
    public void testStoreArtifactOnFtp(){
       // Create a simple file for artifact content.
       File artifactFile = new File(rootDir, "vfsartifact.txt");
       try {writeToFile(artifactFile, "Test content");}
       catch (Exception e){
          fail("Exception while creating the artifact file");
       }
       // Store artifact within repository using different structures.
       repository.setBaseUrl("ftp://laurent.broudoux:o5knybkg@ftpperso.free.fr");
       repository.setStructureDefinition("${release}/${versionInfo}");
       try {repository.storeArtifact(artifact, artifactFile);}
       catch (Exception e){
          fail("Exception while storing artifact within repository");
       }
    }
 
    /** Tear down resources (ie: delete created directory) */
    public void tearDown() throws Exception{
       if (rootDir != null && rootDir.isDirectory()){
          deleteDir(rootDir);
          rootDir.delete();
       }
    }
 
 
    // Private ------------------------------------------------------------------
 
    /** Delete a directory content. */
    private void deleteDir(File directory){
       if (directory != null && directory.isDirectory()){
          File[] files = directory.listFiles();
          for (int i=0; i < files.length; i++){
             File file = files[i];
             if (file.isDirectory())
                deleteDir(file);
             file.delete();
          }
       }
    }
 
    /** Write content for testing. */
    private void writeToFile(File targetFile, String content) throws Exception{
       FileWriter writer = new FileWriter(targetFile);
       writer.write(content);
       writer.close();
    }
 
    /** Compare file contents. */
    private boolean compareFileContent(File origine, File destination){
       boolean result = true;
       BufferedReader oReader = null;
       BufferedReader dReader = null;
       try{
          String oLine = null;
          oReader = new BufferedReader(new FileReader(origine));
          dReader = new BufferedReader(new FileReader(destination));
          while (result && (oLine = oReader.readLine()) != null){
             String dLine = dReader.readLine();
             if (!oLine.equals(dLine))
                result = false;
          }
       }
       catch (Exception e) {result = false;}
       finally{
          try {oReader.close();}
          catch (Exception e) {/* Do nothing here... */}
          try {dReader.close();}
          catch (Exception e) {/* Do nothing here... */}
       }
       return result;
    }
 }