package org.apache.maven.wagon.tck.http;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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.
   */
  
  import java.io.File;
  import java.io.IOException;
  import java.util.HashSet;
  import java.util.Set;
  
  import org.apache.log4j.Logger;
  import org.apache.maven.wagon.ConnectionException;
  import org.apache.maven.wagon.Wagon;
  import org.apache.maven.wagon.authentication.AuthenticationException;
  import org.apache.maven.wagon.authentication.AuthenticationInfo;
  import org.apache.maven.wagon.proxy.ProxyInfo;
  import org.apache.maven.wagon.repository.Repository;
  import org.apache.maven.wagon.tck.http.fixture.ServerFixture;
  import org.codehaus.plexus.DefaultPlexusContainer;
  import org.codehaus.plexus.PlexusContainer;
  import org.codehaus.plexus.component.configurator.ComponentConfigurationException;
  import org.codehaus.plexus.component.repository.exception.ComponentLifecycleException;
  import org.codehaus.plexus.util.FileUtils;
  import org.junit.After;
  import org.junit.AfterClass;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import static org.apache.maven.wagon.tck.http.util.TestUtil.getResource;
  
  public abstract class HttpWagonTests
  {
  
      private ServerFixture serverFixture;
  
      private static PlexusContainer container;
  
      private Wagon wagon;
  
      private static WagonTestCaseConfigurator configurator;
  
      private String baseUrl;
  
      private static final Set<File> tmpFiles = new HashSet<File>();
  
      private Repository repo;
  
      private final Set<Object> notificationTargets = new HashSet<Object>();
  
      protected static Logger logger = Logger.getLogger( HttpWagonTests.class );
  
      @Before
      public void beforeEach()
          throws Exception
      {
          serverFixture = new ServerFixture( isSsl() );
          serverFixture.start();
          wagon = (Wagon) container.lookup( Wagon.ROLE, configurator.getWagonHint() );
      }
  
      @BeforeClass
      public static void beforeAll()
          throws Exception
      {
          File keystore = getResource( ServerFixture.SERVER_SSL_KEYSTORE_RESOURCE_PATH );
  
          System.setProperty( "javax.net.ssl.keyStore", keystore.getAbsolutePath() );
          System.setProperty( "javax.net.ssl.keyStorePassword", ServerFixture.SERVER_SSL_KEYSTORE_PASSWORD );
          System.setProperty( "javax.net.ssl.trustStore", keystore.getAbsolutePath() );
          System.setProperty( "javax.net.ssl.trustStorePassword", ServerFixture.SERVER_SSL_KEYSTORE_PASSWORD );
  
          container = new DefaultPlexusContainer();
          //container.initialize();
          //container.start();
  
          configurator = (WagonTestCaseConfigurator) container.lookup( WagonTestCaseConfigurator.class.getName() );
      }
  
      @After
      public void afterEach()
      {
          try
          {
              wagon.disconnect();
         }
         catch ( ConnectionException e )
         {
             e.printStackTrace();
         }
 
         for ( Object obj : notificationTargets )
         {
             synchronized ( obj )
             {
                 obj.notify();
             }
         }
 
         if ( serverFixture != null )
         {
             try
             {
                 serverFixture.stop();
             }
             catch ( Exception e )
             {
                 e.printStackTrace();
             }
         }
 
         try
         {
             container.release( wagon );
         }
         catch ( ComponentLifecycleException e )
         {
             e.printStackTrace();
         }
     }
 
     @AfterClass
     public static void afterAll()
     {
         for ( File f : tmpFiles )
         {
             if ( f.exists() )
             {
                 try
                 {
                     FileUtils.forceDelete( f );
                 }
                 catch ( IOException e )
                 {
                     e.printStackTrace();
                 }
             }
         }
 
         if ( container != null )
         {
             try
             {
                 container.release( configurator );
             }
             catch ( ComponentLifecycleException e )
             {
                 e.printStackTrace();
             }
 
             container.dispose();
         }
     }
 
     protected void addNotificationTarget( final Object target )
     {
         notificationTargets.add( target );
     }
 
     protected File newTempFile()
         throws IOException
     {
         File f = File.createTempFile( "wagon-target.", ".file" );
         f.deleteOnExit();
 
         return f;
     }
 
     protected boolean isSsl()
     {
         return false;
     }
 
     protected ProxyInfo newProxyInfo()
     {
         ProxyInfo info = new ProxyInfo();
         info.setType( isSsl() ? "https" : "http" );
         info.setHost( ServerFixture.SERVER_HOST );
         info.setPort( getPort() );
 
         return info;
     }
 
     protected boolean isSupported()
     {
         StackTraceElement[] elements = new Throwable().getStackTrace();
         String testCaseId = null;
         String lastMethodName = null;
         for ( StackTraceElement e : elements )
         {
             if ( !e.getClassName().startsWith( getClass().getPackage().getName() ) )
             {
                 testCaseId = lastMethodName;
                 break;
             }
             else
             {
                 lastMethodName = e.getMethodName();
             }
         }
 
         if ( testCaseId == null || !configurator.isSupported( testCaseId ) )
         {
             logger.error( "Cannot run test: " + testCaseId
                           + ". Wagon under test does not support this test case." );
             return false;
         }
 
         return true;
     }
 
     protected boolean initTest( final AuthenticationInfo auth, final ProxyInfo proxy )
         throws ComponentConfigurationException, ConnectionException, AuthenticationException
     {
         return initTest( getBaseUrl(), auth, proxy );
     }
 
     protected boolean initTest( final String baseUrl, final AuthenticationInfo auth, final ProxyInfo proxy )
         throws ComponentConfigurationException, ConnectionException, AuthenticationException
     {
         StackTraceElement[] elements = new Throwable().getStackTrace();
         String testCaseId = null;
         String lastMethodName = null;
         for ( StackTraceElement e : elements )
         {
             if ( !e.getClassName().startsWith( getClass().getPackage().getName() ) )
             {
                 testCaseId = lastMethodName;
                 break;
             }
             else
             {
                 lastMethodName = e.getMethodName();
             }
         }
 
         if ( testCaseId == null || !configurator.configureWagonForTest( wagon, testCaseId ) )
         {
             logger.error( "Cannot run test: " + testCaseId
                           + ". Wagon under test does not support this test case." );
 
             return false;
         }
 
         try
         {
             serverFixture.start();
         }
         catch ( Exception e )
         {
             throw new IllegalStateException( "Failed to start: " + e.getMessage(), e );
         }
 
         repo = new Repository( "test", baseUrl );
 
         wagon.connect( repo, auth, proxy );
 
         return true;
     }
 
     protected int getPort()
     {
         return serverFixture.getHttpPort();
     }
 
     protected int getPortPropertyValue()
     {
         return Integer.parseInt( System.getProperty( "test.port", "-1" ) );
     }
 
     protected String getBaseUrl()
     {
         if ( baseUrl == null )
         {
             StringBuilder sb = new StringBuilder();
             sb.append( isSsl() ? "https" : "http" );
             sb.append( "://" + ServerFixture.SERVER_HOST + ":" );
             sb.append( getPort() );
 
             baseUrl = sb.toString();
         }
 
         return baseUrl;
     }
 
     protected ServerFixture getServerFixture()
     {
         return serverFixture;
     }
 
     protected static PlexusContainer getContainer()
     {
         return container;
     }
 
     protected Wagon getWagon()
     {
         return wagon;
     }
 
     protected static WagonTestCaseConfigurator getConfigurator()
     {
         return configurator;
     }
 
     protected static Set<File> getTmpfiles()
     {
         return tmpFiles;
     }
 
     protected Repository getRepo()
     {
         return repo;
     }
 
 }