mercury-1.0.0-alpha-2/mercury-it/src/test/java/org/apache/maven/mercury/repository/tests/AbstractRepositoryReaderM2Test.java - maven-mercury - Git at Google

 /**
  *  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.
  */
 package org.apache.maven.mercury.repository.tests;

 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;

 import junit.framework.TestCase;

 import org.apache.maven.mercury.artifact.Artifact;
 import org.apache.maven.mercury.artifact.ArtifactBasicMetadata;
 import org.apache.maven.mercury.artifact.QualityRange;
 import org.apache.maven.mercury.builder.api.DependencyProcessor;
 import org.apache.maven.mercury.crypto.api.StreamVerifierAttributes;
 import org.apache.maven.mercury.crypto.api.StreamVerifierException;
 import org.apache.maven.mercury.crypto.api.StreamVerifierFactory;
 import org.apache.maven.mercury.crypto.pgp.PgpStreamVerifierFactory;
 import org.apache.maven.mercury.crypto.sha.SHA1VerifierFactory;
 import org.apache.maven.mercury.repository.api.ArtifactBasicResults;
 import org.apache.maven.mercury.repository.api.ArtifactResults;
 import org.apache.maven.mercury.repository.api.Repository;
 import org.apache.maven.mercury.repository.api.RepositoryException;
 import org.apache.maven.mercury.repository.api.RepositoryReader;
 import org.apache.maven.mercury.transport.api.Server;

 /**
  *
  *
  * @author Oleg Gusakov
  * @version $Id$
  *
  */
 public abstract class AbstractRepositoryReaderM2Test
 extends TestCase
 {
   Repository repo;
   DependencyProcessor mdProcessor;
   RepositoryReader reader;
   List<ArtifactBasicMetadata> query;

   ArtifactBasicMetadata bmd;

   private static final String publicKeyFile = "/pgp/pubring.gpg";
   private static final String secretKeyFile = "/pgp/secring.gpg";

   boolean goodOs = false;

   Server server;
   HashSet<StreamVerifierFactory> factories;


   @Override
   protected void setUp()
   throws Exception
   {
     String os = System.getProperty("os.name");
     if( "Mac OS X".equals( os ) )
       goodOs = true;
   }
   //------------------------------------------------------------------------------
   public void testReadReleaseVersion()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:[3,3]");
     query.add( bmd );

     ArtifactBasicResults res = reader.readVersions( query );

     assertNotNull( res );
     assertFalse( res.hasExceptions() );
     assertTrue( res.hasResults() );

     assertEquals( 1, res.getResults().size() );

     List<ArtifactBasicMetadata> ror = res.getResult( bmd );

     assertNotNull( ror );

     if( res.hasExceptions() )
       System.out.println( res.getExceptions() );

     assertEquals( 1, ror.size() );

 //    System.out.println(qr);
   }
   //------------------------------------------------------------------------------
   public void testReadReleaseRange()
   throws IllegalArgumentException, RepositoryException
   {
     repo.setRepositoryQualityRange( QualityRange.RELEASES_ONLY );

     bmd = new ArtifactBasicMetadata("a:a:[3,)");
     query.add( bmd );

     ArtifactBasicResults res = reader.readVersions( query );

     assertNotNull( res );

     if( res.hasExceptions() )
       System.out.println( res.getExceptions() );

     assertFalse( res.hasExceptions() );
     assertTrue( res.hasResults() );

     assertEquals( 1, res.getResults().size() );

     List<ArtifactBasicMetadata> qr = res.getResult( bmd );

     assertNotNull( qr );
     assertTrue( qr.size() > 1 );

     assertFalse( qr.contains( new ArtifactBasicMetadata("a:a:5-SNAPSHOT") ) );

     System.out.println("query "+bmd+"->"+qr);

     ArtifactBasicResults depRes = reader.readDependencies( qr );

     assertNotNull( depRes );
     assertFalse( depRes.hasExceptions() );
     assertTrue( depRes.hasResults() );

     ArtifactBasicMetadata a3 = new ArtifactBasicMetadata("a:a:3");

     assertTrue( depRes.hasResults( a3 ) );

     List<ArtifactBasicMetadata> deps = depRes.getResult( a3 );
     assertNotNull( deps );
     assertFalse( deps.isEmpty() );

     System.out.println(deps);

     assertTrue( deps.contains( new ArtifactBasicMetadata("b:b:2") ) );
     assertTrue( deps.contains( new ArtifactBasicMetadata("c:c:(1,)") ) );

   }
   //------------------------------------------------------------------------------
   public void testReadArtifacts()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:3");
     query.add( bmd );

     ArtifactResults ror = reader.readArtifacts( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
       System.out.println( ror.getExceptions() );

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<Artifact> res = ror.getResults(bmd);

     assertNotNull( res );
     assertEquals( 1, res.size() );

     Artifact da = res.get( 0 );

     assertNotNull( da );
     assertNotNull( da.getFile() );
     assertTrue( da.getFile().exists() );
     assertNotNull( da.getPomBlob() );
   }
   //------------------------------------------------------------------------------
   public void testReadSnapshot()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:5-SNAPSHOT");
     query.add( bmd );

     ArtifactResults ror = reader.readArtifacts( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
       System.out.println( ror.getExceptions() );

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<Artifact> res = ror.getResults(bmd);

     assertNotNull( res );
     assertEquals( 1, res.size() );

     Artifact da = res.get( 0 );

     assertNotNull( da );
     assertNotNull( da.getFile() );
     assertTrue( da.getFile().exists() );
     assertEquals( 159630, da.getFile().length() );
     assertNotNull( da.getPomBlob() );
   }
   //------------------------------------------------------------------------------
   public void testReadSnapshotTS()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:5-20080807.234713-11");
     query.add( bmd );

     ArtifactResults ror = reader.readArtifacts( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
       System.out.println( ror.getExceptions() );

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<Artifact> res = ror.getResults(bmd);

     assertNotNull( res );
     assertEquals( 1, res.size() );

     Artifact da = res.get( 0 );

     assertNotNull( da );
     assertNotNull( da.getFile() );
     assertTrue( da.getFile().exists() );
     assertEquals( 14800, da.getFile().length() );
     assertNotNull( da.getPomBlob() );
   }
   //------------------------------------------------------------------------------
   public void testReadVersionsLatest()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:LATEST");
     query.add( bmd );

     ArtifactBasicResults ror = reader.readVersions( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
     {
       Map<ArtifactBasicMetadata, Exception> exs = ror.getExceptions();

       for( ArtifactBasicMetadata bmd : exs.keySet() )
       {
         System.out.println( "\n==========> "+bmd.toString());
         exs.get( bmd ).printStackTrace();
       }
     }

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<ArtifactBasicMetadata> deps = ror.getResult(bmd);

     assertNotNull( deps );
     assertEquals( 1, deps.size() );
     assertTrue( deps.contains( new ArtifactBasicMetadata("a:a:5-SNAPSHOT") ) );

   }
   //------------------------------------------------------------------------------
   public void testReadVersionsRelease()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:RELEASE");
     query.add( bmd );

     ArtifactBasicResults ror = reader.readVersions( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
       System.out.println( ror.getExceptions() );

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<ArtifactBasicMetadata> deps = ror.getResult(bmd);

     assertNotNull( deps );
     assertEquals( 1, deps.size() );
     assertTrue( deps.contains( new ArtifactBasicMetadata("a:a:4") ) );

   }
   //------------------------------------------------------------------------------
   public void testReadLatest()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:LATEST");
     query.add( bmd );

     ArtifactResults ror = reader.readArtifacts( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
       System.out.println( ror.getExceptions() );

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<Artifact> res = ror.getResults(bmd);

     assertNotNull( res );
     assertEquals( 1, res.size() );

     Artifact da = res.get( 0 );

     assertNotNull( da );
     assertEquals( "5-SNAPSHOT", da.getVersion() );

     assertNotNull( da.getFile() );
     assertTrue( da.getFile().exists() );
     assertEquals( 159630, da.getFile().length() );
     assertNotNull( da.getPomBlob() );

   }
   //------------------------------------------------------------------------------
   public void testReadRelease()
   throws IllegalArgumentException, RepositoryException
   {
     bmd = new ArtifactBasicMetadata("a:a:RELEASE");
     query.add( bmd );

     ArtifactResults ror = reader.readArtifacts( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
       System.out.println( ror.getExceptions() );

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<Artifact> res = ror.getResults(bmd);

     assertNotNull( res );
     assertEquals( 1, res.size() );

     Artifact da = res.get( 0 );

     assertNotNull( da );
     assertEquals( "4", da.getVersion() );

     assertNotNull( da.getFile() );
     assertTrue( da.getFile().exists() );
     assertEquals( 14800, da.getFile().length() );
     assertNotNull( da.getPomBlob() );
   }
   //------------------------------------------------------------------------------
   public void testReadAndVerifyGoodArtifact()
   throws IllegalArgumentException, RepositoryException, StreamVerifierException
   {
     // verifiers
     factories = new HashSet<StreamVerifierFactory>();
     factories.add(
         new PgpStreamVerifierFactory(
                 new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, false, true )
                 , getClass().getResourceAsStream( publicKeyFile )
                                     )
                   );
     factories.add( new SHA1VerifierFactory( true, false ) );

     if( goodOs )
       server.setReaderStreamVerifierFactories(factories);

     bmd = new ArtifactBasicMetadata("a:a:4");
     query.add( bmd );

     ArtifactResults ror = reader.readArtifacts( query );

     assertNotNull( ror );

     if( ror.hasExceptions() )
     {
       System.out.println("===> unexpected Exceptions");
       for( Exception e : ror.getExceptions().values() )
         System.out.println( e.getClass().getName()+": "+e.getMessage() );
       System.out.println("<=== unexpected Exceptions");
     }

     assertFalse( ror.hasExceptions() );
     assertTrue( ror.hasResults() );

     List<Artifact> res = ror.getResults(bmd);

     assertNotNull( res );
     assertEquals( 1, res.size() );

     Artifact da = res.get( 0 );

     assertNotNull( da );
     assertNotNull( da.getFile() );
     assertTrue( da.getFile().exists() );
     assertNotNull( da.getPomBlob() );
   }
   //------------------------------------------------------------------------------
   public void testReadAndVerifyArtifactNoSig()
   throws IllegalArgumentException, StreamVerifierException
   {
     // verifiers
     factories = new HashSet<StreamVerifierFactory>();
     factories.add(
         new PgpStreamVerifierFactory(
                 new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, false, true )
                 , getClass().getResourceAsStream( publicKeyFile )
                                     )
                   );

     server.setReaderStreamVerifierFactories(factories);

     bmd = new ArtifactBasicMetadata("a:a:3");
     query.add( bmd );

     ArtifactResults ror = null;
     try
     {
       ror = reader.readArtifacts( query );
     }
     catch( RepositoryException e )
     {
       System.out.println( "Expected exception: "+e.getMessage() );
       return;
     }
     assertNotNull( ror );
     if( !ror.hasExceptions() )
       fail( "Artifact a:a:3 does not have .asc signature, PGP verifier is not lenient, but this did not cause a RepositoryException" );

     System.out.println("Expected Exceptions: "+ror.getExceptions() );
   }
   //------------------------------------------------------------------------------
   public void testReadAndVerifyArtifactBadSig()
   throws IllegalArgumentException, StreamVerifierException
   {
     // verifiers
     factories = new HashSet<StreamVerifierFactory>();
     factories.add(
         new PgpStreamVerifierFactory(
                 new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, false, true )
                 , getClass().getResourceAsStream( publicKeyFile )
                                     )
                   );
     server.setReaderStreamVerifierFactories(factories);

     bmd = new ArtifactBasicMetadata("a:a:2");
     query.add( bmd );

     ArtifactResults ror = null;
     try
     {
       ror = reader.readArtifacts( query );
     }
     catch( RepositoryException e )
     {
       System.out.println( "Expected exception: "+e.getMessage() );
       return;
     }
     assertNotNull( ror );
     if( !ror.hasExceptions() )
       fail( "Artifact a:a:2 does have a bad .asc (PGP) signature, PGP verifier is not lenient, but this did not cause a RepositoryException" );

     System.out.println("Expected Exceptions: "+ror.getExceptions() );
   }
   //------------------------------------------------------------------------------
   public void testReadAndVerifyArtifactNoSigLenientVerifier()
   throws IllegalArgumentException, StreamVerifierException
   {
     // verifiers
     factories = new HashSet<StreamVerifierFactory>();
     factories.add(
         new PgpStreamVerifierFactory(
                 new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, true, true )
                 , getClass().getResourceAsStream( publicKeyFile )
                                     )
                   );
     if( goodOs )
     {
       factories.add( new SHA1VerifierFactory(true,false) );
       server.setReaderStreamVerifierFactories(factories);
     }

     bmd = new ArtifactBasicMetadata("a:a:3");
     query.add( bmd );

     ArtifactResults ror = null;
     try
     {
       ror = reader.readArtifacts( query );
     }
     catch( RepositoryException e )
     {
       fail( "Artifact a:a:3 does not have .asc signature, PGP verifier is lenient, but still caused a RepositoryException: "+e.getMessage() );
     }
     if( ror.hasExceptions() )
       fail( "Artifact a:a:3 does not have .asc signature, PGP verifier is lenient, but still caused exceptions: "+ror.getExceptions() );
   }
   //------------------------------------------------------------------------------
   //------------------------------------------------------------------------------
 }
	/**
	* 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.
	*/
	package org.apache.maven.mercury.repository.tests;

	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;

	import junit.framework.TestCase;

	import org.apache.maven.mercury.artifact.Artifact;
	import org.apache.maven.mercury.artifact.ArtifactBasicMetadata;
	import org.apache.maven.mercury.artifact.QualityRange;
	import org.apache.maven.mercury.builder.api.DependencyProcessor;
	import org.apache.maven.mercury.crypto.api.StreamVerifierAttributes;
	import org.apache.maven.mercury.crypto.api.StreamVerifierException;
	import org.apache.maven.mercury.crypto.api.StreamVerifierFactory;
	import org.apache.maven.mercury.crypto.pgp.PgpStreamVerifierFactory;
	import org.apache.maven.mercury.crypto.sha.SHA1VerifierFactory;
	import org.apache.maven.mercury.repository.api.ArtifactBasicResults;
	import org.apache.maven.mercury.repository.api.ArtifactResults;
	import org.apache.maven.mercury.repository.api.Repository;
	import org.apache.maven.mercury.repository.api.RepositoryException;
	import org.apache.maven.mercury.repository.api.RepositoryReader;
	import org.apache.maven.mercury.transport.api.Server;

	/**
	*
	*
	* @author Oleg Gusakov
	* @version $Id$
	*
	*/
	public abstract class AbstractRepositoryReaderM2Test
	extends TestCase
	{
	Repository repo;
	DependencyProcessor mdProcessor;
	RepositoryReader reader;
	List<ArtifactBasicMetadata> query;

	ArtifactBasicMetadata bmd;

	private static final String publicKeyFile = "/pgp/pubring.gpg";
	private static final String secretKeyFile = "/pgp/secring.gpg";

	boolean goodOs = false;

	Server server;
	HashSet<StreamVerifierFactory> factories;


	@Override
	protected void setUp()
	throws Exception
	{
	String os = System.getProperty("os.name");
	if( "Mac OS X".equals( os ) )
	goodOs = true;
	}
	//------------------------------------------------------------------------------
	public void testReadReleaseVersion()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:[3,3]");
	query.add( bmd );

	ArtifactBasicResults res = reader.readVersions( query );

	assertNotNull( res );
	assertFalse( res.hasExceptions() );
	assertTrue( res.hasResults() );

	assertEquals( 1, res.getResults().size() );

	List<ArtifactBasicMetadata> ror = res.getResult( bmd );

	assertNotNull( ror );

	if( res.hasExceptions() )
	System.out.println( res.getExceptions() );

	assertEquals( 1, ror.size() );

	// System.out.println(qr);
	}
	//------------------------------------------------------------------------------
	public void testReadReleaseRange()
	throws IllegalArgumentException, RepositoryException
	{
	repo.setRepositoryQualityRange( QualityRange.RELEASES_ONLY );

	bmd = new ArtifactBasicMetadata("a:a:[3,)");
	query.add( bmd );

	ArtifactBasicResults res = reader.readVersions( query );

	assertNotNull( res );

	if( res.hasExceptions() )
	System.out.println( res.getExceptions() );

	assertFalse( res.hasExceptions() );
	assertTrue( res.hasResults() );

	assertEquals( 1, res.getResults().size() );

	List<ArtifactBasicMetadata> qr = res.getResult( bmd );

	assertNotNull( qr );
	assertTrue( qr.size() > 1 );

	assertFalse( qr.contains( new ArtifactBasicMetadata("a:a:5-SNAPSHOT") ) );

	System.out.println("query "+bmd+"->"+qr);

	ArtifactBasicResults depRes = reader.readDependencies( qr );

	assertNotNull( depRes );
	assertFalse( depRes.hasExceptions() );
	assertTrue( depRes.hasResults() );

	ArtifactBasicMetadata a3 = new ArtifactBasicMetadata("a:a:3");

	assertTrue( depRes.hasResults( a3 ) );

	List<ArtifactBasicMetadata> deps = depRes.getResult( a3 );
	assertNotNull( deps );
	assertFalse( deps.isEmpty() );

	System.out.println(deps);

	assertTrue( deps.contains( new ArtifactBasicMetadata("b:b:2") ) );
	assertTrue( deps.contains( new ArtifactBasicMetadata("c:c:(1,)") ) );

	}
	//------------------------------------------------------------------------------
	public void testReadArtifacts()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:3");
	query.add( bmd );

	ArtifactResults ror = reader.readArtifacts( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	System.out.println( ror.getExceptions() );

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<Artifact> res = ror.getResults(bmd);

	assertNotNull( res );
	assertEquals( 1, res.size() );

	Artifact da = res.get( 0 );

	assertNotNull( da );
	assertNotNull( da.getFile() );
	assertTrue( da.getFile().exists() );
	assertNotNull( da.getPomBlob() );
	}
	//------------------------------------------------------------------------------
	public void testReadSnapshot()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:5-SNAPSHOT");
	query.add( bmd );

	ArtifactResults ror = reader.readArtifacts( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	System.out.println( ror.getExceptions() );

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<Artifact> res = ror.getResults(bmd);

	assertNotNull( res );
	assertEquals( 1, res.size() );

	Artifact da = res.get( 0 );

	assertNotNull( da );
	assertNotNull( da.getFile() );
	assertTrue( da.getFile().exists() );
	assertEquals( 159630, da.getFile().length() );
	assertNotNull( da.getPomBlob() );
	}
	//------------------------------------------------------------------------------
	public void testReadSnapshotTS()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:5-20080807.234713-11");
	query.add( bmd );

	ArtifactResults ror = reader.readArtifacts( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	System.out.println( ror.getExceptions() );

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<Artifact> res = ror.getResults(bmd);

	assertNotNull( res );
	assertEquals( 1, res.size() );

	Artifact da = res.get( 0 );

	assertNotNull( da );
	assertNotNull( da.getFile() );
	assertTrue( da.getFile().exists() );
	assertEquals( 14800, da.getFile().length() );
	assertNotNull( da.getPomBlob() );
	}
	//------------------------------------------------------------------------------
	public void testReadVersionsLatest()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:LATEST");
	query.add( bmd );

	ArtifactBasicResults ror = reader.readVersions( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	{
	Map<ArtifactBasicMetadata, Exception> exs = ror.getExceptions();

	for( ArtifactBasicMetadata bmd : exs.keySet() )
	{
	System.out.println( "\n==========> "+bmd.toString());
	exs.get( bmd ).printStackTrace();
	}
	}

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<ArtifactBasicMetadata> deps = ror.getResult(bmd);

	assertNotNull( deps );
	assertEquals( 1, deps.size() );
	assertTrue( deps.contains( new ArtifactBasicMetadata("a:a:5-SNAPSHOT") ) );

	}
	//------------------------------------------------------------------------------
	public void testReadVersionsRelease()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:RELEASE");
	query.add( bmd );

	ArtifactBasicResults ror = reader.readVersions( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	System.out.println( ror.getExceptions() );

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<ArtifactBasicMetadata> deps = ror.getResult(bmd);

	assertNotNull( deps );
	assertEquals( 1, deps.size() );
	assertTrue( deps.contains( new ArtifactBasicMetadata("a:a:4") ) );

	}
	//------------------------------------------------------------------------------
	public void testReadLatest()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:LATEST");
	query.add( bmd );

	ArtifactResults ror = reader.readArtifacts( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	System.out.println( ror.getExceptions() );

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<Artifact> res = ror.getResults(bmd);

	assertNotNull( res );
	assertEquals( 1, res.size() );

	Artifact da = res.get( 0 );

	assertNotNull( da );
	assertEquals( "5-SNAPSHOT", da.getVersion() );

	assertNotNull( da.getFile() );
	assertTrue( da.getFile().exists() );
	assertEquals( 159630, da.getFile().length() );
	assertNotNull( da.getPomBlob() );

	}
	//------------------------------------------------------------------------------
	public void testReadRelease()
	throws IllegalArgumentException, RepositoryException
	{
	bmd = new ArtifactBasicMetadata("a:a:RELEASE");
	query.add( bmd );

	ArtifactResults ror = reader.readArtifacts( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	System.out.println( ror.getExceptions() );

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<Artifact> res = ror.getResults(bmd);

	assertNotNull( res );
	assertEquals( 1, res.size() );

	Artifact da = res.get( 0 );

	assertNotNull( da );
	assertEquals( "4", da.getVersion() );

	assertNotNull( da.getFile() );
	assertTrue( da.getFile().exists() );
	assertEquals( 14800, da.getFile().length() );
	assertNotNull( da.getPomBlob() );
	}
	//------------------------------------------------------------------------------
	public void testReadAndVerifyGoodArtifact()
	throws IllegalArgumentException, RepositoryException, StreamVerifierException
	{
	// verifiers
	factories = new HashSet<StreamVerifierFactory>();
	factories.add(
	new PgpStreamVerifierFactory(
	new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, false, true )
	, getClass().getResourceAsStream( publicKeyFile )
	)
	);
	factories.add( new SHA1VerifierFactory( true, false ) );

	if( goodOs )
	server.setReaderStreamVerifierFactories(factories);

	bmd = new ArtifactBasicMetadata("a:a:4");
	query.add( bmd );

	ArtifactResults ror = reader.readArtifacts( query );

	assertNotNull( ror );

	if( ror.hasExceptions() )
	{
	System.out.println("===> unexpected Exceptions");
	for( Exception e : ror.getExceptions().values() )
	System.out.println( e.getClass().getName()+": "+e.getMessage() );
	System.out.println("<=== unexpected Exceptions");
	}

	assertFalse( ror.hasExceptions() );
	assertTrue( ror.hasResults() );

	List<Artifact> res = ror.getResults(bmd);

	assertNotNull( res );
	assertEquals( 1, res.size() );

	Artifact da = res.get( 0 );

	assertNotNull( da );
	assertNotNull( da.getFile() );
	assertTrue( da.getFile().exists() );
	assertNotNull( da.getPomBlob() );
	}
	//------------------------------------------------------------------------------
	public void testReadAndVerifyArtifactNoSig()
	throws IllegalArgumentException, StreamVerifierException
	{
	// verifiers
	factories = new HashSet<StreamVerifierFactory>();
	factories.add(
	new PgpStreamVerifierFactory(
	new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, false, true )
	, getClass().getResourceAsStream( publicKeyFile )
	)
	);

	server.setReaderStreamVerifierFactories(factories);

	bmd = new ArtifactBasicMetadata("a:a:3");
	query.add( bmd );

	ArtifactResults ror = null;
	try
	{
	ror = reader.readArtifacts( query );
	}
	catch( RepositoryException e )
	{
	System.out.println( "Expected exception: "+e.getMessage() );
	return;
	}
	assertNotNull( ror );
	if( !ror.hasExceptions() )
	fail( "Artifact a:a:3 does not have .asc signature, PGP verifier is not lenient, but this did not cause a RepositoryException" );

	System.out.println("Expected Exceptions: "+ror.getExceptions() );
	}
	//------------------------------------------------------------------------------
	public void testReadAndVerifyArtifactBadSig()
	throws IllegalArgumentException, StreamVerifierException
	{
	// verifiers
	factories = new HashSet<StreamVerifierFactory>();
	factories.add(
	new PgpStreamVerifierFactory(
	new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, false, true )
	, getClass().getResourceAsStream( publicKeyFile )
	)
	);
	server.setReaderStreamVerifierFactories(factories);

	bmd = new ArtifactBasicMetadata("a:a:2");
	query.add( bmd );

	ArtifactResults ror = null;
	try
	{
	ror = reader.readArtifacts( query );
	}
	catch( RepositoryException e )
	{
	System.out.println( "Expected exception: "+e.getMessage() );
	return;
	}
	assertNotNull( ror );
	if( !ror.hasExceptions() )
	fail( "Artifact a:a:2 does have a bad .asc (PGP) signature, PGP verifier is not lenient, but this did not cause a RepositoryException" );

	System.out.println("Expected Exceptions: "+ror.getExceptions() );
	}
	//------------------------------------------------------------------------------
	public void testReadAndVerifyArtifactNoSigLenientVerifier()
	throws IllegalArgumentException, StreamVerifierException
	{
	// verifiers
	factories = new HashSet<StreamVerifierFactory>();
	factories.add(
	new PgpStreamVerifierFactory(
	new StreamVerifierAttributes( PgpStreamVerifierFactory.DEFAULT_EXTENSION, true, true )
	, getClass().getResourceAsStream( publicKeyFile )
	)
	);
	if( goodOs )
	{
	factories.add( new SHA1VerifierFactory(true,false) );
	server.setReaderStreamVerifierFactories(factories);
	}

	bmd = new ArtifactBasicMetadata("a:a:3");
	query.add( bmd );

	ArtifactResults ror = null;
	try
	{
	ror = reader.readArtifacts( query );
	}
	catch( RepositoryException e )
	{
	fail( "Artifact a:a:3 does not have .asc signature, PGP verifier is lenient, but still caused a RepositoryException: "+e.getMessage() );
	}
	if( ror.hasExceptions() )
	fail( "Artifact a:a:3 does not have .asc signature, PGP verifier is lenient, but still caused exceptions: "+ror.getExceptions() );
	}
	//------------------------------------------------------------------------------
	//------------------------------------------------------------------------------
	}