/**
    * 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.FileOutputStream;
  import java.io.BufferedReader;
  import java.io.InputStream;
  import java.util.Date;
  /**
   * JUnit test case for testing the simple file system repository implementation.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class SimpleFileSystemRepositoryTest extends TestCase{
  
     // Attributes ---------------------------------------------------------------
  
     /** The root directory for FS repository. */
     private File rootDir = null;
     /** The FS repository to test. */
     private SimpleFileSystemRepository repository = null;
  
     /** Our test artifact. */
     private Deliverable artifact = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Default constructor. Build a test case using a name. */
     public SimpleFileSystemRepositoryTest(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(SimpleFileSystemRepositoryTest.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 simple fs repository in user dir.
        repository = new SimpleFileSystemRepository();
        repository.setRootDirectory(userDir + "/" + rootDir.getName());
  
        // 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 repository */
     public void testStoreArtifact(){
        // Create a simple file for artifact content.
        File artifactFile = new File(repository.getRootDirectory(), "artifact.txt");
        try {writeToFile(artifactFile, "Test content");}
        catch (Exception e){
           fail("Exception while creating the artifact file");
        }
        // Store artifact within repository using different structures.
        repository.setStructureDefinition("${release}/${versionInfo}");
       try {repository.storeArtifact(artifact, artifactFile);}
       catch (Exception e){
          fail("Exception while storing artifact within repository");
       }
       File targetFile = new File(repository.getRootDirectory() + "/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 retrieval of an artifact within repository */
    public void testGetArtifact(){
       // First, ensure an artifact has been stored.
       testStoreArtifact();
 
       // Then, read and check incoming input stream.
       InputStream is = null;
       FileOutputStream fos = null;
       try{
          // Getting input and opening output.
          is = repository.getArtifact(artifact);
          fos = new FileOutputStream(new File(rootDir, "output.txt"));
          // Read is and write on fos unsing a buffer of bytes.
          int bytes = 0;
          byte[] buffer = new byte[8192];
          while ((bytes = is.read(buffer, 0, 8192)) != -1)
             fos.write(buffer, 0, bytes);
       }
       catch (Exception e){
          fail("Exception while getting artifact from repository");
       }
       finally{
          try {is.close();}
          catch (Exception e) {/* Do nothing here... */}
          try {fos.close();}
          catch (Exception e) {/* Do nothing here... */}
       }
       File sourceFile = new File(repository.getRootDirectory() + "/1.0/01/mytype-r1.0-v01.txt");
       File outputFile = new File(rootDir, "output.txt");
       assertTrue("Artifact is extracted from repository", outputFile.isFile());
       assertTrue("Extracted content is equals to content in repository", compareFileContent(sourceFile, outputFile));
 
       // Modify artifact and check exceptions.
       artifact.setKey("mytype-r1.0-v02");
       try {repository.getArtifact(artifact);}
       catch (RepositoryException re){
          assertTrue("ConnectionException 'cause no artifact in repository", re instanceof ConnectionException);
       }
    }
 
    /** 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;
    }
 }