/* 
    * Copyright (c) 2005-2011, Fraunhofer-Gesellschaft
    * All rights reserved.
    * 
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions are
    * met:
    * 
    * (1) Redistributions of source code must retain the above copyright
   *     notice, this list of conditions and the disclaimer at the end.
   *     Redistributions in binary form must reproduce the above copyright
   *     notice, this list of conditions and the following disclaimer in
   *     the documentation and/or other materials provided with the
   *     distribution.
   * 
   * (2) Neither the name of Fraunhofer nor the names of its
   *     contributors may be used to endorse or promote products derived
   *     from this software without specific prior written permission.
   * 
   * DISCLAIMER
   * 
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *  
   */
  package org.ogf.graap.wsag.it;
  
  import java.text.MessageFormat;
  
  import javax.security.auth.login.LoginContext;
  
  import junit.framework.Assert;
  
  import org.apache.log4j.Logger;
  import org.ogf.graap.wsag.api.security.KeystoreLoginContext;
  import org.ogf.graap.wsag.api.security.KeystoreProperties;
  import org.ogf.graap.wsag.client.api.AgreementClient;
  import org.ogf.graap.wsag.client.api.AgreementFactoryClient;
  import org.ogf.graap.wsag.client.api.AgreementFactoryRegistryClient;
  import org.w3.x2005.x08.addressing.EndpointReferenceType;
  
  /**
   * Abstract test case for the WSAG4J framework. This test case uses the WSAG4J client API, but the
   * instantiation of the clients is left to the concrete implementations. Multiple WSRF stack implementations
   * can therefore use the same tests.
   * 
   * @author owaeld
   * 
   */
  public abstract class AbstractIntegrationTest extends WsagTestCase
  {
  
      private static final Logger LOG = Logger.getLogger( AbstractIntegrationTest.class );
  
      /**
       * default WSAG4J URL
       */
      private static String url = "http://127.0.0.1:8080/wsag4j";
  
      /**
       * @return the url
       */
      public static String getUrl()
      {
          return url;
      }
  
      /**
       * @param url
       *            the url to set
       */
      public static void setUrl( String url )
      {
          AbstractIntegrationTest.url = url;
      }
  
      /**
       * number of factories configured in the framework
       */
      private static final int EXPECTED_FACTORIES = 1;
  
      /**
       * number of templates at factory 1
       */
      public static final int EXPECTED_TEMPLATES_FACTORY_1 = 6;
  
      /**
       * number of templates at factory 1
       */
      public static final int EXPECTED_TEMPLATES_FACTORY_2 = 2;
 
     static
     {
         String gatewayURL = System.getProperty( "wsag4j.gateway.address" );
         if ( gatewayURL != null )
         {
             LOG.info( "Gateway address was set via SystemPorperties: " + gatewayURL );
             url = gatewayURL;
         }
         else
         {
             LOG.info( "Gateway address was not set via SystemPorperties." );
         }
     }
 
     /**
      * @param name
      *            the test name
      */
     protected AbstractIntegrationTest( String name )
     {
         super( name );
     }
 
     /**
      * initializes the agreement factory clients for the test
      * 
      * @throws Exception
      *             indicates an error while initializing thefactory clients
      */
     @Override
     protected void setUp() throws Exception
     {
         super.setUp();
 
         EndpointReferenceType epr = EndpointReferenceType.Factory.newInstance();
         epr.addNewAddress().setStringValue( url );
 
         AgreementFactoryRegistryClient registry = null;
         AgreementFactoryClient[] factories = null;
 
         try
         {
             registry = AgreementFactoryRegistryClient.FACTORY.newInstance( epr, getLoginContext() );
             factories = registry.listAgreementFactories();
         }
         catch ( Exception ex )
         {
             Assert.fail( "Failed to initialize factory list. " + ex.getMessage() );
         }
         //
         // before running a test, we must make sure that we have a clean
         // server environment. No agreement resources should exist on the server.
         //
         try
         {
             for ( int i = 0; i < factories.length; i++ )
             {
                 AgreementClient[] agreements = factories[i].listAgreements();
                 for ( int j = 0; j < agreements.length; j++ )
                 {
                     agreements[j].destroy();
                 }
             }
         }
         catch ( Exception e )
         {
             String message =
                 MessageFormat.format( "Error while cleaning up existing agreement resources. Error: {0}",
                     new Object[] { e.getMessage() } );
             LOG.error( message );
             throw e;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected void tearDown() throws Exception
     {
         super.tearDown();
     }
 
     /**
      * 
      * @return the agreement factory clients used for testing
      */
     public static AgreementFactoryClient[] getAgreementFactoryClients()
     {
         AgreementFactoryClient[] factories = null;
         try
         {
 
             LoginContext loginContext = AbstractIntegrationTest.getLoginContext();
 
             // START SNIPPET: ListAgreementFactories
             EndpointReferenceType epr = EndpointReferenceType.Factory.newInstance();
             epr.addNewAddress().setStringValue( AbstractIntegrationTest.url );
 
             AgreementFactoryRegistryClient registry =
                 AgreementFactoryRegistryClient.FACTORY.newInstance( epr, loginContext );
             factories = registry.listAgreementFactories();
             // END SNIPPET: ListAgreementFactories
         }
         catch ( Exception ex )
         {
             LOG.error( ex );
         }
 
         return factories;
     }
 
     /**
      * Returns the agreement factory test client with the given id.
      * 
      * @param id
      *            the factory id
      * 
      * @return the agreement factory client with the given id
      */
     public static AgreementFactoryClient getAgreementFactoryClient( String id )
     {
         AgreementFactoryClient factory = null;
         try
         {
 
             LoginContext loginContext = AbstractIntegrationTest.getLoginContext();
 
             // START SNIPPET: GetAgreementFactory
             EndpointReferenceType epr = EndpointReferenceType.Factory.newInstance();
             epr.addNewAddress().setStringValue( AbstractIntegrationTest.url );
 
             AgreementFactoryRegistryClient registry =
                 AgreementFactoryRegistryClient.FACTORY.newInstance( epr, loginContext );
             factory = registry.getFactory( id );
             // END SNIPPET: GetAgreementFactory
 
             assertNotNull( "requested factory does not exist", factory );
         }
         catch ( Exception ex )
         {
             LOG.error( ex );
         }
 
         return factory;
     }
 
     /**
      * @return the login context
      * 
      * @throws Exception
      *             indicates a failure loading the login context (keystore)
      */
     public static LoginContext getLoginContext() throws Exception
     {
         /*
          * create a keystore login context
          */
         LOG.info( "Create Keystore-LoginContext" );
 
         // START SNIPPET: CreateLoginContext
         KeystoreProperties properties = new KeystoreProperties();
         properties.setKeyStoreAlias( "wsag4j-user" );
         properties.setPrivateKeyPassword( "user@wsag4j" );
 
         properties.setKeyStoreType( "JKS" );
         properties.setKeystoreFilename( "/wsag4j-client-keystore.jks" );
         properties.setKeystorePassword( "user@wsag4j" );
 
         properties.setTruststoreType( "JKS" );
         properties.setTruststoreFilename( "/wsag4j-client-keystore.jks" );
         properties.setTruststorePassword( "user@wsag4j" );
 
         LoginContext loginContext = new KeystoreLoginContext( properties );
         loginContext.login();
         // END SNIPPET: CreateLoginContext
 
         return loginContext;
     }
 
     /**
      * Returns the default number of expected agreement factories at an endpoint.
      * 
      * @return the number of expected agreement factories
      */
     public int getDefaultFactoryCount()
     {
         return EXPECTED_FACTORIES;
     }
 }