source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.metadata.repository;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import junit.framework.TestCase;
  23 import org.apache.archiva.checksum.ChecksumAlgorithm;
  24 import org.apache.archiva.metadata.QueryParameter;
  25 import org.apache.archiva.metadata.generic.GenericMetadataFacet;
  26 import org.apache.archiva.metadata.generic.GenericMetadataFacetFactory;
  27 import org.apache.archiva.metadata.model.*;
  28 import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner;
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33 import org.springframework.test.context.ContextConfiguration;
  34
  35 import java.text.SimpleDateFormat;
  36 import java.time.ZoneId;
  37 import java.time.ZonedDateTime;
  38 import java.util.*;
  39 import java.util.stream.Collectors;
  40 import java.util.stream.Stream;
  41
  42 import static org.assertj.core.api.Assertions.assertThat;
  43
  44 @RunWith( ArchivaSpringJUnit4ClassRunner.class )
  45 @ContextConfiguration( locations = {"classpath*:/META-INF/spring-context.xml", "classpath*:/spring-context.xml"} )
  46 public abstract class AbstractMetadataRepositoryTest
  47     extends TestCase
  48 {
  49     protected static final String OTHER_REPO_ID = "other-repo";
  50
  51
  52     protected static final String TEST_REPO_ID = "test";
  53
  54     protected static final String TEST_PROJECT = "myproject";
  55
  56     protected static final String TEST_NAMESPACE = "mytest";
  57
  58     protected static final String TEST_PROJECT_VERSION = "1.0";
  59
  60     private static final String TEST_PROJECT_VERSION_2_0 = "2.0";
  61
  62     protected static final String TEST_URL = "http://archiva.apache.org";
  63
  64     private static final Organization TEST_ORGANIZATION = new Organization( "Apache", "http://apache.org" );
  65
  66     private static final String TEST_FACET_ID = "test-facet-id";
  67
  68     private static final String TEST_NAME = "test/name";
  69
  70     private static final String TEST_VALUE = "test-value";
  71
  72     private static final String UNKNOWN = "unknown";
  73
  74     private static final String TEST_SHA256 = "e43857b4e75e04a09d167564ca9a4636e5d233035483ba4ecf1243e34325d565";
  75
  76     private static final String TEST_MD5 = "bd4a9b642562547754086de2dab26b7d";
  77
  78     private static final String TEST_SHA1 = "2e5daf0201ddeb068a62d5e08da18657ab2c6be9";
  79
  80     private static final String TEST_METADATA_KEY = "testkey";
  81
  82     private static final String TEST_METADATA_VALUE = "testmetadata";
  83
  84     protected Logger log = LoggerFactory.getLogger( getClass( ) );
  85
  86     protected int assertMaxTries =10;
  87     protected int assertRetrySleepMs=500;
  88
  89     /*
  90      * Used by tryAssert to allow to throw exceptions in the lambda expression.
  91      */
  92     @FunctionalInterface
  93     protected interface AssertFunction
  94     {
  95         void accept( ) throws Exception;
  96     }
  97
  98     protected void tryAssert( AssertFunction func ) throws Exception
  99     {
 100         tryAssert( func, assertMaxTries, assertRetrySleepMs );
 101     }
 102
 103
 104     protected abstract RepositorySessionFactory getSessionFactory( );
 105
 106     protected abstract MetadataRepository getRepository( );
 107
 108     /*
 109      * Runs the assert method until the assert is successful or the number of retries
 110      * is reached. This is needed because the JCR Oak index update is asynchronous, so updates
 111      * may not be visible immediately after the modification.
 112      */
 113     private void tryAssert( AssertFunction func, int retries, int sleepMillis ) throws Exception
 114     {
 115         Throwable t = null;
 116         int retry = retries;
 117         while ( retry-- > 0 )
 118         {
 119             try
 120             {
 121                 func.accept( );
 122                 return;
 123             }
 124             catch ( Exception | AssertionError e )
 125             {
 126                 t = e;
 127                 Thread.currentThread( ).sleep( sleepMillis );
 128                 log.warn( "Retrying assert {}: {}", retry, e.getMessage( ) );
 129             }
 130         }
 131         log.warn( "Retries: {}, Exception: {}", retry, t.getMessage( ) );
 132         if ( retry <= 0 && t != null )
 133         {
 134             if ( t instanceof RuntimeException )
 135             {
 136                 throw (RuntimeException) t;
 137             }
 138             else if ( t instanceof Exception )
 139             {
 140                 throw (Exception) t;
 141             }
 142             else if ( t instanceof Error )
 143             {
 144                 throw (Error) t;
 145             }
 146         }
 147     }
 148
 149
 150     public static List<MetadataFacetFactory> createTestMetadataFacetFactories( )
 151     {
 152         List<MetadataFacetFactory> factories = new ArrayList<>( );
 153         factories.add( new MetadataFacetFactory<TestMetadataFacet>( )
 154         {
 155             @Override
 156             public TestMetadataFacet createMetadataFacet( )
 157             {
 158                 return new TestMetadataFacet( TEST_METADATA_VALUE );
 159             }
 160
 161             @Override
 162             public TestMetadataFacet createMetadataFacet( String repositoryId, String name )
 163             {
 164                 return new TestMetadataFacet( TEST_FACET_ID, TEST_METADATA_VALUE, name );
 165             }
 166
 167             @Override
 168             public Class<TestMetadataFacet> getFacetClass( )
 169             {
 170                 return TestMetadataFacet.class;
 171             }
 172
 173             @Override
 174             public String getFacetId( )
 175             {
 176                 return TEST_FACET_ID;
 177             }
 178         } );
 179
 180         // for the getArtifactsByProjectVersionFacet tests
 181         factories.add( new GenericMetadataFacetFactory( ) );
 182
 183         return factories;
 184     }
 185
 186
 187     @Test
 188     public void testRootNamespaceWithNoMetadataRepository( )
 189         throws Exception
 190     {
 191         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 192         {
 193             tryAssert( ( ) -> {
 194                 Collection<String> namespaces = getRepository( ).getRootNamespaces( session, TEST_REPO_ID );
 195                 assertThat( namespaces ).isNotNull( ).isEmpty( );
 196             } );
 197         }
 198     }
 199
 200     @Test
 201     public void testGetNamespaceOnly( )
 202         throws Exception
 203     {
 204         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 205         {
 206             tryAssert( ( ) -> {
 207                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isEmpty( );
 208             } );
 209             getRepository( ).updateNamespace( session, TEST_REPO_ID, TEST_NAMESPACE );
 210
 211             tryAssert( ( ) -> {
 212                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isNotEmpty( ).contains(
 213                     TEST_NAMESPACE ).hasSize( 1 );
 214             } );
 215             getRepository( ).removeNamespace( session, TEST_REPO_ID, TEST_NAMESPACE );
 216
 217             tryAssert( ( ) -> {
 218                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isEmpty( );
 219             } );
 220         }
 221     }
 222
 223     @Test
 224     public void testGetProjectOnly( )
 225         throws Exception
 226     {
 227         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 228         {
 229
 230             tryAssert( ( ) -> {
 231                 assertNull( getRepository( ).getProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 232                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isEmpty( );
 233             } );
 234
 235             ProjectMetadata project = new ProjectMetadata( );
 236             project.setId( TEST_PROJECT );
 237             project.setNamespace( TEST_NAMESPACE );
 238
 239             getRepository( ).updateProject( session, TEST_REPO_ID, project );
 240
 241             tryAssert( ( ) -> {
 242                 ProjectMetadata proj = getRepository( ).getProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 243                 assertEquals( TEST_PROJECT, proj.getId( ) );
 244                 assertEquals( TEST_NAMESPACE, proj.getNamespace( ) );
 245             } );
 246
 247             // test that namespace is also constructed
 248
 249
 250             tryAssert( ( ) -> {
 251                 Collection<String> namespaces = getRepository( ).getRootNamespaces( session, TEST_REPO_ID );
 252
 253                 assertThat( namespaces ).isNotNull( ).isNotEmpty( ).contains( TEST_NAMESPACE ).hasSize( 1 );
 254             } );
 255         }
 256     }
 257
 258     @Test
 259     public void testGetProjectVersionOnly( )
 260         throws Exception
 261     {
 262         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 263         {
 264
 265             tryAssert( ( ) -> {
 266                 assertNull( getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) );
 267                 assertNull( getRepository( ).getProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) );
 268                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isEmpty( );
 269             } );
 270
 271             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 272             metadata.setId( TEST_PROJECT_VERSION );
 273
 274             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 275
 276             metadata = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 277             assertEquals( TEST_PROJECT_VERSION, metadata.getId( ) );
 278
 279             tryAssert( ( ) -> {
 280
 281                 // test that namespace and project is also constructed
 282                 Collection<String> namespaces = getRepository( ).getRootNamespaces( session, TEST_REPO_ID );
 283
 284                 assertThat( namespaces ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( TEST_NAMESPACE );
 285
 286             } );
 287
 288             tryAssert( ( ) -> {
 289
 290                 ProjectMetadata projectMetadata = getRepository( ).getProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 291                 assertNotNull( projectMetadata );
 292                 assertEquals( TEST_PROJECT, projectMetadata.getId( ) );
 293                 assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace( ) );
 294             } );
 295         }
 296     }
 297
 298     @Test
 299     public void testGetArtifactOnly( )
 300         throws Exception
 301     {
 302         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 303         {
 304
 305             tryAssert( ( ) -> {
 306                 assertThat( new ArrayList<>(
 307                     getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
 308                         TEST_PROJECT, TEST_PROJECT_VERSION ) ) ).isNotNull( ).isEmpty( );
 309                 assertThat(
 310                     getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION ) ).isNull( );
 311                 assertThat( getRepository( ).getProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ) ).isNull( );
 312
 313                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isEmpty( );
 314
 315             } );
 316
 317             ArtifactMetadata metadata = createArtifact( );
 318
 319             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 320
 321             tryAssert( ( ) -> {
 322                 Collection<ArtifactMetadata> artifacts =
 323                     getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 324                 //assertEquals( Collections.singletonList( metadata ), new ArrayList<ArtifactMetadata>( artifacts ) );
 325                 assertThat( artifacts ).containsExactly( metadata );
 326                 // test that namespace, project and project version is also constructed
 327
 328                 assertThat( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ) ).isNotNull( ).isNotEmpty( ).contains(
 329                     TEST_NAMESPACE ).hasSize( 1 );
 330
 331                 ProjectMetadata projectMetadata = getRepository( ).getProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
 332                 assertEquals( TEST_PROJECT, projectMetadata.getId( ) );
 333                 assertEquals( TEST_NAMESPACE, projectMetadata.getNamespace( ) );
 334
 335                 ProjectVersionMetadata projectVersionMetadata =
 336                     getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 337                 assertEquals( TEST_PROJECT_VERSION, projectVersionMetadata.getId( ) );
 338             } );
 339         }
 340     }
 341
 342     @Test
 343     public void testUpdateProjectVersionMetadataWithNoOtherArchives( )
 344         throws Exception
 345     {
 346         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 347         {
 348
 349             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 350             metadata.setId( TEST_PROJECT_VERSION );
 351             MailingList mailingList = new MailingList( );
 352             mailingList.setName( "Foo List" );
 353             mailingList.setOtherArchives( Collections.<String>emptyList( ) );
 354             metadata.setMailingLists( Arrays.asList( mailingList ) );
 355             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 356
 357             metadata = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 358             assertEquals( TEST_PROJECT_VERSION, metadata.getId( ) );
 359
 360             List<MailingList> mailingLists = metadata.getMailingLists( );
 361
 362             assertThat( mailingLists ).isNotNull( ).isNotEmpty( ).hasSize( 1 );
 363
 364             mailingList = metadata.getMailingLists( ).get( 0 );
 365             assertEquals( "Foo List", mailingList.getName( ) );
 366
 367             List<String> others = mailingList.getOtherArchives( );
 368             assertThat( others ).isNotNull( ).isEmpty( );
 369         }
 370     }
 371
 372     @Test
 373     public void testUpdateProjectVersionMetadataWithAllElements( )
 374         throws Exception
 375     {
 376
 377         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 378         {
 379
 380             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 381             metadata.setId( TEST_PROJECT_VERSION );
 382
 383             metadata.setName( "project name" );
 384             metadata.setDescription( "project description" );
 385             metadata.setUrl( "the url" );
 386
 387             MailingList mailingList = new MailingList( );
 388             mailingList.setName( "Foo List" );
 389             mailingList.setUnsubscribeAddress( "UnsubscribeAddress" );
 390             mailingList.setSubscribeAddress( "SubscribeAddress" );
 391             mailingList.setPostAddress( "PostAddress" );
 392             mailingList.setMainArchiveUrl( "MainArchiveUrl" );
 393             mailingList.setOtherArchives( Arrays.asList( "other archive" ) );
 394             metadata.setMailingLists( Arrays.asList( mailingList ) );
 395
 396             Scm scm = new Scm( );
 397             scm.setConnection( "connection" );
 398             scm.setDeveloperConnection( "dev conn" );
 399             scm.setUrl( "url" );
 400             metadata.setScm( scm );
 401
 402             CiManagement ci = new CiManagement( );
 403             ci.setSystem( "system" );
 404             ci.setUrl( "ci url" );
 405             metadata.setCiManagement( ci );
 406
 407             IssueManagement tracker = new IssueManagement( );
 408             tracker.setSystem( "system" );
 409             tracker.setUrl( "issue tracker url" );
 410             metadata.setIssueManagement( tracker );
 411
 412             metadata.setOrganization( TEST_ORGANIZATION );
 413
 414             License l = new License( );
 415             l.setName( "license name" );
 416             l.setUrl( "license url" );
 417             metadata.addLicense( l );
 418
 419             Dependency d = new Dependency( );
 420             d.setArtifactId( "artifactId" );
 421             d.setClassifier( "classifier" );
 422             d.setGroupId( "groupId" );
 423             d.setScope( "scope" );
 424             d.setSystemPath( "system path" );
 425             d.setType( "type" );
 426             d.setVersion( "version" );
 427             d.setOptional( true );
 428             metadata.addDependency( d );
 429
 430             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 431
 432             metadata = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 433             assertEquals( TEST_PROJECT_VERSION, metadata.getId( ) );
 434             assertEquals( TEST_PROJECT_VERSION, metadata.getVersion( ) );
 435             assertEquals( "project name", metadata.getName( ) );
 436             assertEquals( "project description", metadata.getDescription( ) );
 437             assertEquals( "the url", metadata.getUrl( ) );
 438
 439             assertEquals( "connection", metadata.getScm( ).getConnection( ) );
 440             assertEquals( "dev conn", metadata.getScm( ).getDeveloperConnection( ) );
 441             assertEquals( "url", metadata.getScm( ).getUrl( ) );
 442
 443             assertEquals( "system", metadata.getCiManagement( ).getSystem( ) );
 444             assertEquals( "ci url", metadata.getCiManagement( ).getUrl( ) );
 445
 446             assertEquals( "system", metadata.getIssueManagement( ).getSystem( ) );
 447             assertEquals( "issue tracker url", metadata.getIssueManagement( ).getUrl( ) );
 448
 449             assertEquals( TEST_ORGANIZATION.getName( ), metadata.getOrganization( ).getName( ) );
 450             assertEquals( TEST_ORGANIZATION.getUrl( ), metadata.getOrganization( ).getUrl( ) );
 451
 452             assertEquals( 1, metadata.getMailingLists( ).size( ) );
 453             MailingList retrievedMailingList = metadata.getMailingLists( ).get( 0 );
 454             assertEquals( mailingList.getName( ), retrievedMailingList.getName( ) );
 455             assertEquals( mailingList.getMainArchiveUrl( ), retrievedMailingList.getMainArchiveUrl( ) );
 456             assertEquals( mailingList.getPostAddress( ), retrievedMailingList.getPostAddress( ) );
 457             assertEquals( mailingList.getSubscribeAddress( ), retrievedMailingList.getSubscribeAddress( ) );
 458             assertEquals( mailingList.getUnsubscribeAddress( ), retrievedMailingList.getUnsubscribeAddress( ) );
 459             assertThat( retrievedMailingList.getOtherArchives( ) ) //
 460                 .isNotNull( ) //
 461                 .isNotEmpty( ) //
 462                 .hasSize( 1 ) //
 463                 .contains( "other archive" );
 464
 465             assertEquals( 1, metadata.getLicenses( ).size( ) );
 466             l = metadata.getLicenses( ).get( 0 );
 467             assertEquals( "license name", l.getName( ) );
 468             assertEquals( "license url", l.getUrl( ) );
 469
 470             assertEquals( 1, metadata.getDependencies( ).size( ) );
 471             d = metadata.getDependencies( ).get( 0 );
 472             assertEquals( "artifactId", d.getArtifactId( ) );
 473             assertEquals( "classifier", d.getClassifier( ) );
 474             assertEquals( "groupId", d.getGroupId( ) );
 475             assertEquals( "scope", d.getScope( ) );
 476             assertEquals( "system path", d.getSystemPath( ) );
 477             assertEquals( "type", d.getType( ) );
 478             assertEquals( "version", d.getVersion( ) );
 479             assertTrue( d.isOptional( ) );
 480         }
 481     }
 482
 483     @Test
 484     public void testUpdateProjectVersionMetadataIncomplete( )
 485         throws Exception
 486     {
 487         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 488         {
 489
 490             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 491             metadata.setId( TEST_PROJECT_VERSION );
 492             metadata.setIncomplete( true );
 493             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 494
 495             tryAssert( ( ) -> {
 496                 ProjectVersionMetadata metadata1 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 497                 assertEquals( true, metadata1.isIncomplete( ) );
 498                 assertNull( metadata1.getCiManagement( ) );
 499                 assertNull( metadata1.getScm( ) );
 500                 assertNull( metadata1.getIssueManagement( ) );
 501                 assertNull( metadata1.getOrganization( ) );
 502                 assertTrue( metadata1.getDescription( )==null || "".equals(metadata1.getDescription()) );
 503                 assertTrue( metadata1.getName( )==null || "".equals(metadata1.getName()) );
 504                 assertEquals( TEST_PROJECT_VERSION, metadata1.getId( ) );
 505                 assertEquals( TEST_PROJECT_VERSION, metadata1.getVersion( ) );
 506                 assertTrue( metadata1.getMailingLists( ).isEmpty( ) );
 507                 assertTrue( metadata1.getLicenses( ).isEmpty( ) );
 508                 assertTrue( metadata1.getDependencies( ).isEmpty( ) );
 509             } );
 510         }
 511     }
 512
 513     @Test
 514     public void testUpdateProjectVersionMetadataWithExistingFacets( )
 515         throws Exception
 516     {
 517         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 518         {
 519
 520             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 521             metadata.setId( TEST_PROJECT_VERSION );
 522             MetadataFacet facet = new TestMetadataFacet( "baz" );
 523             metadata.addFacet( facet );
 524             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 525
 526             tryAssert( ( ) -> {
 527
 528                 ProjectVersionMetadata metadata1 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 529                 assertEquals( Collections.singleton( TEST_FACET_ID ), metadata1.getFacetIds( ) );
 530             } );
 531
 532             metadata = new ProjectVersionMetadata( );
 533             metadata.setId( TEST_PROJECT_VERSION );
 534             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 535
 536             tryAssert( ( ) -> {
 537
 538                 ProjectVersionMetadata metadata2 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 539                 assertEquals( Collections.singleton( TEST_FACET_ID ), metadata2.getFacetIds( ) );
 540                 TestMetadataFacet testFacet = (TestMetadataFacet) metadata2.getFacet( TEST_FACET_ID );
 541                 assertEquals( "baz", testFacet.getValue( ) );
 542             } );
 543         }
 544     }
 545
 546     @Test
 547     public void testUpdateProjectVersionMetadataWithNoExistingFacets( )
 548         throws Exception
 549     {
 550         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 551         {
 552
 553             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 554             metadata.setId( TEST_PROJECT_VERSION );
 555             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 556
 557
 558             tryAssert( ( ) -> {
 559                 ProjectVersionMetadata metadata1 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 560
 561                 assertThat( metadata1.getFacetIds( ) ).isNotNull( ).isEmpty( );
 562             } );
 563
 564             ProjectVersionMetadata metadata1 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 565             metadata = new ProjectVersionMetadata( );
 566             metadata.setId( TEST_PROJECT_VERSION );
 567             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 568
 569             tryAssert( ( ) -> {
 570                 ProjectVersionMetadata metadata2 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 571                 assertThat( metadata2.getFacetIds( ) ).isNotNull( ).isEmpty( );
 572             } );
 573         }
 574     }
 575
 576     @Test
 577     public void testUpdateProjectVersionMetadataWithExistingFacetsFacetPropertyWasRemoved( )
 578         throws Exception
 579     {
 580         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 581         {
 582
 583             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
 584             metadata.setId( TEST_PROJECT_VERSION );
 585
 586             Map<String, String> additionalProps = new HashMap<>( );
 587             additionalProps.put( "deleteKey", "deleteValue" );
 588
 589             MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 590             metadata.addFacet( facet );
 591             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 592
 593
 594             tryAssert( ( ) -> {
 595
 596                 ProjectVersionMetadata metad = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 597
 598                 assertThat( metad.getFacetIds( ) ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( TEST_FACET_ID );
 599
 600
 601             } );
 602
 603             ProjectVersionMetadata metad = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 604             TestMetadataFacet testFacet = (TestMetadataFacet) metad.getFacet( TEST_FACET_ID );
 605             Map<String, String> facetProperties = testFacet.toProperties( );
 606
 607             assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 608
 609             facetProperties.remove( "deleteKey" );
 610
 611             TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue( ), facetProperties );
 612             metadata.addFacet( newTestFacet );
 613
 614             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
 615
 616
 617             tryAssert( ( ) -> {
 618                 ProjectVersionMetadata metad2 = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 619
 620                 assertThat( metad2.getFacetIds( ) ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( TEST_FACET_ID );
 621                 TestMetadataFacet testFacet2 = (TestMetadataFacet) metad2.getFacet( TEST_FACET_ID );
 622                 assertFalse( testFacet2.toProperties( ).containsKey( "deleteKey" ) );
 623             } );
 624         }
 625     }
 626
 627     @Test
 628     public void testGetArtifactsDoesntReturnProjectVersionMetadataFacets( )
 629         throws Exception
 630     {
 631         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 632         {
 633
 634             ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata( );
 635             versionMetadata.setId( TEST_PROJECT_VERSION );
 636
 637             MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz" );
 638             versionMetadata.addFacet( facet );
 639             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, versionMetadata );
 640             ArtifactMetadata artifactMetadata = createArtifact( );
 641             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifactMetadata );
 642             session.save( );
 643
 644             tryAssert( ( ) -> {
 645
 646
 647                 Collection<ArtifactMetadata> artifacts =
 648                     getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 649                 assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
 650
 651                 artifacts = getRepository( ).getArtifacts( session, TEST_REPO_ID );
 652                 assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
 653
 654                 artifacts = getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_SHA1 );
 655                 assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
 656
 657                 artifacts = getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_MD5 );
 658                 assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
 659
 660                 artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, null );
 661                 assertEquals( Collections.singletonList( artifactMetadata ), new ArrayList<>( artifacts ) );
 662             } );
 663         }
 664     }
 665
 666     @Test
 667     public void testUpdateArtifactMetadataWithExistingFacetsFacetPropertyWasRemoved( )
 668         throws Exception
 669     {
 670         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 671         {
 672
 673             ArtifactMetadata metadata = createArtifact( );
 674
 675             Map<String, String> additionalProps = new HashMap<>( );
 676             additionalProps.put( "deleteKey", "deleteValue" );
 677
 678             MetadataFacet facet = new TestMetadataFacet( TEST_FACET_ID, "baz", additionalProps );
 679             metadata.addFacet( facet );
 680             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 681
 682             tryAssert( ( ) -> {
 683                 Collection<ArtifactMetadata> artifacts =
 684                     getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 685
 686                 assertThat( artifacts ).isNotNull( ).isNotEmpty( ).hasSize( 1 );
 687             } );
 688
 689             Collection<ArtifactMetadata> artifacts =
 690                 getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 691             metadata = artifacts.iterator( ).next( );
 692
 693             Collection<String> ids = metadata.getFacetIds( );
 694             assertThat( ids ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( TEST_FACET_ID );
 695
 696             TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 697             Map<String, String> facetProperties = testFacet.toProperties( );
 698
 699             assertEquals( "deleteValue", facetProperties.get( "deleteKey" ) );
 700
 701             facetProperties.remove( "deleteKey" );
 702
 703             TestMetadataFacet newTestFacet = new TestMetadataFacet( TEST_FACET_ID, testFacet.getValue( ), facetProperties );
 704             metadata.addFacet( newTestFacet );
 705
 706             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 707             session.save( );
 708
 709             tryAssert( ( ) -> {
 710                 Collection<ArtifactMetadata> artifacts1 = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 711
 712                 assertThat( artifacts1 ).isNotNull( ).isNotEmpty( ).hasSize( 1 );
 713             } );
 714             Collection<ArtifactMetadata> artifacts1 = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
 715             metadata = artifacts.iterator( ).next( );
 716
 717             ids = metadata.getFacetIds( );
 718             assertThat( ids ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( TEST_FACET_ID );
 719
 720             testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 721
 722             Map<String, String> props = testFacet.toProperties( );
 723             assertThat( props ).isNotNull( ).doesNotContainKey( "deleteKey" );
 724         }
 725     }
 726
 727     @Test
 728     public void testUpdateArtifactMetadataWithExistingFacets( )
 729         throws Exception
 730     {
 731         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 732         {
 733
 734             ArtifactMetadata metadata = createArtifact( );
 735             MetadataFacet facet = new TestMetadataFacet( "baz" );
 736             metadata.addFacet( facet );
 737             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 738
 739             metadata = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
 740                 TEST_PROJECT, TEST_PROJECT_VERSION ).iterator( ).next( );
 741             assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds( ) );
 742
 743             metadata = createArtifact( );
 744             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 745
 746             metadata = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
 747                 TEST_PROJECT, TEST_PROJECT_VERSION ).iterator( ).next( );
 748             assertEquals( Collections.singleton( TEST_FACET_ID ), metadata.getFacetIds( ) );
 749             TestMetadataFacet testFacet = (TestMetadataFacet) metadata.getFacet( TEST_FACET_ID );
 750             assertEquals( "baz", testFacet.getValue( ) );
 751         }
 752     }
 753
 754     @Test
 755     public void testUpdateArtifactMetadataWithNoExistingFacets( )
 756         throws Exception
 757     {
 758         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 759         {
 760             ArtifactMetadata metadata = createArtifact( );
 761             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 762
 763             tryAssert( ( ) -> {
 764
 765                 ArtifactMetadata metadata2 = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
 766                     TEST_PROJECT, TEST_PROJECT_VERSION ).iterator( ).next( );
 767                 assertEquals( Collections.<String>emptyList( ), new ArrayList<String>( metadata2.getFacetIds( ) ) );
 768
 769             } );
 770
 771             metadata = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
 772                 TEST_PROJECT, TEST_PROJECT_VERSION ).iterator( ).next( );
 773             metadata = createArtifact( );
 774             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, metadata );
 775
 776
 777             tryAssert( ( ) -> {
 778                 ArtifactMetadata metadata3 = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
 779                     TEST_PROJECT, TEST_PROJECT_VERSION ).iterator( ).next( );
 780                 assertEquals( Collections.<String>emptyList( ), new ArrayList<String>( metadata3.getFacetIds( ) ) );
 781             } );
 782         }
 783     }
 784
 785     @Test
 786     public void testGetMetadataFacet( )
 787         throws Exception
 788     {
 789         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 790         {
 791             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 792
 793             TestMetadataFacet test =
 794                 (TestMetadataFacet) getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 795
 796             assertEquals( new TestMetadataFacet( TEST_VALUE ), test );
 797
 798         }
 799     }
 800
 801     @Test
 802     public void testGetMetadataFacetByClass( )
 803         throws Exception
 804     {
 805         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 806         {
 807             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 808
 809             TestMetadataFacet test =
 810                 (TestMetadataFacet) getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TestMetadataFacet.class, TEST_NAME );
 811
 812             assertEquals( new TestMetadataFacet( TEST_VALUE ), test );
 813
 814         }
 815     }
 816
 817     @Test
 818     public void testGetMetadataFacetWhenEmpty( )
 819         throws Exception
 820     {
 821         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 822         {
 823             tryAssert( ( ) -> assertNull( getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ) );
 824         }
 825     }
 826
 827     @Test
 828     public void testGetMetadataFacetWhenUnknownName( )
 829         throws Exception
 830     {
 831         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 832         {
 833             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 834
 835             tryAssert( ( ) -> assertNull( getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, UNKNOWN ) ) );
 836         }
 837     }
 838
 839     @Test
 840     public void testGetMetadataFacetWhenDefaultValue( )
 841         throws Exception
 842     {
 843         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 844         {
 845             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( null ) );
 846
 847             tryAssert( ( ) -> {
 848                 MetadataFacet metadataFacet = getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
 849
 850                 assertEquals( new TestMetadataFacet( TEST_METADATA_VALUE ), metadataFacet );
 851             } );
 852
 853         }
 854     }
 855
 856     @Test
 857     public void testGetMetadataFacetWhenUnknownFacetId( )
 858         throws Exception
 859     {
 860         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 861         {
 862             assertNull( getRepository( ).getMetadataFacet( session, TEST_REPO_ID, UNKNOWN, TEST_NAME ) );
 863
 864         }
 865     }
 866
 867     @Test
 868     public void testGetMetadataFacets( )
 869         throws Exception
 870     {
 871         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 872         {
 873             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 874
 875             assertEquals( Collections.singletonList( TEST_NAME ),
 876                 getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID ) );
 877
 878         }
 879     }
 880
 881     @Test
 882     public void testGetMetadataFacetsStream( )
 883         throws Exception
 884     {
 885         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 886         {
 887             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
 888         }
 889
 890         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 891         {
 892             tryAssert( ( ) -> {
 893                 Stream<TestMetadataFacet> str = getRepository( ).getMetadataFacetStream( session, TEST_REPO_ID, TestMetadataFacet.class );
 894                 assertNotNull( str );
 895                 List<TestMetadataFacet> result = str.collect( Collectors.toList( ) );
 896                 assertEquals( 1, result.size( ) );
 897                 assertNotNull( result.get( 0 ) );
 898                 assertEquals( TEST_NAME, result.get( 0 ).getName( ) );
 899             } );
 900
 901         }
 902     }
 903
 904     @Test
 905     public void testGetMetadataFacetsStreamWithLimit( )
 906         throws Exception
 907     {
 908         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 909         {
 910             for (int i = 0; i<500; i++)
 911             {
 912                 getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_FACET_ID, TEST_VALUE, TEST_NAME+"/"+String.format("%03d",i) ) );
 913             }
 914         }
 915
 916         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 917         {
 918             tryAssert( ( ) -> {
 919                 Stream<TestMetadataFacet> str = getRepository( ).getMetadataFacetStream( session, TEST_REPO_ID, TestMetadataFacet.class, new QueryParameter(0, 100));
 920                 assertNotNull( str );
 921                 List<TestMetadataFacet> result = str.collect( Collectors.toList( ) );
 922                 assertEquals( 100, result.size( ) );
 923                 assertNotNull( result.get( 0 ) );
 924                 for (int i=0; i<10; i++) {
 925                     assertEquals(TEST_NAME + "/" + String.format("%03d",i), result.get(i).getName());
 926                 }
 927             }, 3, 500 );
 928
 929         }
 930     }
 931
 932     @Test
 933     public void testGetMetadataFacetsStreamWithOffset( )
 934             throws Exception
 935     {
 936         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 937         {
 938             for (int i = 0; i<100; i++)
 939             {
 940                 getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_FACET_ID, TEST_VALUE, TEST_NAME+"/"+String.format("%03d", i) ) );
 941             }
 942         }
 943
 944         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 945         {
 946             tryAssert( ( ) -> {
 947                 Stream<TestMetadataFacet> str = getRepository( ).getMetadataFacetStream( session, TEST_REPO_ID, TestMetadataFacet.class, new QueryParameter(5, 10));
 948                 assertNotNull( str );
 949                 List<TestMetadataFacet> result = str.collect( Collectors.toList( ) );
 950                 assertEquals( 10, result.size( ) );
 951                 assertNotNull( result.get( 0 ) );
 952                 for (int i=0; i<10; i++) {
 953                     assertEquals(TEST_NAME + "/" + String.format("%03d",i+5), result.get(i).getName());
 954                 }
 955             }, 3, 500 );
 956
 957         }
 958     }
 959
 960     @Test
 961     public void testGetArtifactsByDateRangeStreamLowerAndUpperBound( )
 962             throws Exception
 963     {
 964         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
 965         {
 966             final ArtifactMetadata artifact1 = createArtifact( );
 967             artifact1.setWhenGathered(ZonedDateTime.now().minusDays(1));
 968             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
 969
 970             ZonedDateTime gatheredNow = ZonedDateTime.now();
 971             final ArtifactMetadata artifact2 = createArtifact( );
 972             String artifact2Id = artifact2.getId() + "-2";
 973             artifact2.setId(artifact2Id);
 974             artifact2.setVersion(TEST_PROJECT_VERSION+"-2");
 975             artifact2.setWhenGathered(gatheredNow);
 976             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
 977             final ArtifactMetadata artifact3 = createArtifact();
 978             String artifact3Id = artifact3.getId() + "-3";
 979             artifact3.setId(artifact3Id);
 980             artifact3.setVersion(TEST_PROJECT_VERSION+"-3");
 981             artifact3.setWhenGathered(gatheredNow.minusSeconds(5));
 982
 983             final ArtifactMetadata artifact4 = createArtifact();
 984             artifact4.setId(artifact4.getId()+"-4");
 985             artifact4.setVersion(TEST_PROJECT_VERSION+"-4");
 986             artifact4.setWhenGathered(gatheredNow.plusDays(1));
 987
 988             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact3 );
 989             session.save( );
 990
 991             ZonedDateTime lower = artifact2.getWhenGathered().minusSeconds(10);
 992             ZonedDateTime upper = artifact2.getWhenGathered().plusSeconds(10);
 993
 994             tryAssert( ( ) -> {
 995                 Stream<ArtifactMetadata> stream = getRepository().getArtifactByDateRangeStream(session, TEST_REPO_ID, lower, upper, new QueryParameter());
 996                 assertNotNull(stream);
 997
 998                 List<ArtifactMetadata> artifacts = stream.collect(Collectors.toList());
 999                 assertEquals(2, artifacts.size());
1000                 assertEquals(artifact3Id, artifacts.get(0).getId());
1001                 assertEquals(artifact2Id, artifacts.get(1).getId());
1002
1003             } );
1004         }
1005     }
1006
1007     @Test
1008     public void testGetMetadataFacetsWhenEmpty( )
1009         throws Exception
1010     {
1011
1012         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1013         {
1014             tryAssert( ( ) -> {
1015
1016                 List<String> facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1017                 assertTrue( facets.isEmpty( ) );
1018             } );
1019         }
1020     }
1021
1022     @Test
1023     public void testRemoveFacets( )
1024         throws Exception
1025     {
1026         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1027         {
1028             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_VALUE ) );
1029
1030             List<String> facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1031             assertFalse( facets.isEmpty( ) );
1032
1033             getRepository( ).removeMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1034
1035             facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1036             assertTrue( facets.isEmpty( ) );
1037
1038         }
1039     }
1040
1041     @Test
1042     public void testRemoveFacetsWhenEmpty( )
1043         throws Exception
1044     {
1045         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1046         {
1047             List<String> facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1048             assertTrue( facets.isEmpty( ) );
1049
1050             getRepository( ).removeMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1051
1052             tryAssert( ( ) -> {
1053                 List<String> facets1 = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1054                 assertTrue( facets1.isEmpty( ) );
1055             } );
1056         }
1057     }
1058
1059     @Test
1060     public void testRemoveFacetsWhenUnknown( )
1061         throws Exception
1062     {
1063         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1064         {
1065 // testing no exception
1066             getRepository( ).removeMetadataFacets( session, TEST_REPO_ID, UNKNOWN );
1067
1068         }
1069     }
1070
1071     @Test
1072     public void testRemoveFacetWhenUnknown( )
1073         throws Exception
1074     {
1075         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1076         {
1077 // testing no exception
1078             getRepository( ).removeMetadataFacet( session, TEST_REPO_ID, UNKNOWN, TEST_NAME );
1079
1080         }
1081     }
1082
1083     @Test
1084     public void testRemoveFacet( )
1085         throws Exception
1086     {
1087         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1088         {
1089             TestMetadataFacet metadataFacet = new TestMetadataFacet( TEST_VALUE );
1090             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, metadataFacet );
1091
1092             assertEquals( metadataFacet, getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
1093             List<String> facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1094             assertFalse( facets.isEmpty( ) );
1095
1096             getRepository( ).removeMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
1097
1098             assertNull( getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) );
1099             facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1100             assertTrue( facets.isEmpty( ) );
1101
1102         }
1103     }
1104
1105     @Test
1106     public void testRemoveFacetWhenEmpty( )
1107         throws Exception
1108     {
1109         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1110         {
1111             tryAssert( ( ) -> {
1112
1113                 List<String> facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1114                 assertThat( facets ).isNotNull( ).isEmpty( );
1115                 assertThat( getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ).isNull( );
1116
1117             } );
1118             getRepository( ).removeMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME );
1119
1120             tryAssert( ( ) -> {
1121
1122                 List<String> facets2 = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, TEST_FACET_ID );
1123                 assertThat( facets2 ).isNotNull( ).isEmpty( );
1124                 assertThat( getRepository( ).getMetadataFacet( session, TEST_REPO_ID, TEST_FACET_ID, TEST_NAME ) ).isNull( );
1125
1126             } );
1127         }
1128     }
1129
1130     @Test
1131     public void hasMetadataFacetStart( )
1132         throws Exception
1133     {
1134         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1135         {
1136             assertFalse( getRepository( ).hasMetadataFacet( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) ) );
1137
1138
1139         }
1140     }
1141
1142     @Test
1143     public void hasMetadataFacet( )
1144         throws Exception
1145     {
1146
1147         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1148         {
1149             assertFalse( getRepository( ).hasMetadataFacet( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) ) );
1150
1151             Calendar cal = Calendar.getInstance( );
1152
1153             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new KindOfRepositoryStatistics( "first", cal.getTime( ) ) );
1154
1155             assertTrue( getRepository( ).hasMetadataFacet( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) ) );
1156
1157             cal.add( Calendar.MINUTE, 2 );
1158
1159             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new KindOfRepositoryStatistics( "second", cal.getTime( ) ) );
1160
1161             cal.add( Calendar.MINUTE, 2 );
1162
1163             getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new KindOfRepositoryStatistics( "third", cal.getTime( ) ) );
1164
1165             List<String> facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) );
1166
1167             assertThat( facets ).isNotNull( ).isNotEmpty( ).hasSize( 3 );
1168
1169             assertTrue( getRepository( ).hasMetadataFacet( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) ) );
1170
1171             getRepository( ).removeMetadataFacets( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) );
1172
1173             assertFalse( getRepository( ).hasMetadataFacet( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) ) );
1174
1175             facets = getRepository( ).getMetadataFacets( session, TEST_REPO_ID, KindOfRepositoryStatistics.class.getName( ) );
1176
1177             assertThat( facets ).isNotNull( ).isEmpty( );
1178
1179
1180         }
1181     }
1182
1183
1184     @Test
1185     public void testGetArtifacts( )
1186         throws Exception
1187     {
1188         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1189         {
1190             ArtifactMetadata artifact1 = createArtifact( );
1191             ArtifactMetadata artifact2 = createArtifact( "pom" );
1192             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1193             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
1194
1195             tryAssert( ( ) -> {
1196                 Collection<ArtifactMetadata> artifacts =
1197                     getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1198                 ArrayList<ArtifactMetadata> actual = new ArrayList<>( artifacts );
1199                 Collections.sort( actual, ( o1, o2 ) -> o1.getId( ).compareTo( o2.getId( ) ) );
1200                 assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
1201             } );
1202
1203         }
1204     }
1205
1206     @Test
1207     public void testGetArtifactStream( )
1208         throws Exception
1209     {
1210         ArtifactMetadata artifact1 = createArtifact( );
1211         ArtifactMetadata artifact2 = createArtifact( "pom" );
1212         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1213         {
1214
1215             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1216             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
1217         }
1218         try ( RepositorySession session = getSessionFactory( ).createSession( ) ) {
1219             tryAssert( ( ) -> {
1220                 Stream<ArtifactMetadata> artifacts =
1221                     getRepository( ).getArtifactStream( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1222                 assertNotNull( artifacts );
1223                 List<ArtifactMetadata> actual = artifacts
1224                     .sorted( ( o1, o2 ) -> o1.getId( ).compareTo( o2.getId( ) ) ).collect( Collectors.toList( ) );
1225                 assertEquals( 2, actual.size( ) );
1226                 assertEquals( Arrays.asList( artifact1, artifact2 ), actual );
1227             } );
1228
1229         }
1230     }
1231
1232     @Test
1233     public void testGetArtifactVersions( )
1234         throws Exception
1235     {
1236         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1237         {
1238             ArtifactMetadata artifact1 = createArtifact( );
1239             String version1 = "1.0-20091212.012345-1";
1240             artifact1.setId( artifact1.getProject( ) + "-" + version1 + ".jar" );
1241             artifact1.setVersion( version1 );
1242             ArtifactMetadata artifact2 = createArtifact( );
1243             String version2 = "1.0-20091212.123456-2";
1244             artifact2.setId( artifact2.getProject( ) + "-" + version2 + ".jar" );
1245             artifact2.setVersion( version2 );
1246             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1247             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
1248
1249             tryAssert( ( ) -> {
1250                 Collection<String> versions =
1251                     getRepository( ).getArtifactVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1252
1253                 assertThat( versions ).isNotNull( ).isNotEmpty( ).contains( version1, version2 );
1254             } );
1255
1256         }
1257     }
1258
1259     @Test
1260     public void testGetArtifactVersionsMultipleArtifactsSingleVersion( )
1261         throws Exception
1262     {
1263         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1264         {
1265             ArtifactMetadata artifact1 = createArtifact( );
1266             artifact1.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
1267             ArtifactMetadata artifact2 = createArtifact( );
1268             artifact2.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "-sources.jar" );
1269             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1270             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 );
1271
1272             tryAssert( ( ) -> {
1273                 Collection<String> versions =
1274                     getRepository( ).getArtifactVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1275
1276                 assertThat( versions ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).containsExactly( TEST_PROJECT_VERSION );
1277             } );
1278
1279
1280         }
1281     }
1282
1283     @Test
1284     public void testGetArtifactsByDateRangeOpen( )
1285         throws Exception
1286     {
1287         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1288         {
1289             ArtifactMetadata artifact = createArtifact( );
1290             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1291             session.save( );
1292
1293             tryAssert( ( ) -> {
1294                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, null );
1295
1296                 assertEquals( Collections.singletonList( artifact ), artifacts );
1297             } );
1298         }
1299     }
1300
1301     @Test
1302     public void testGetArtifactsByDateRangeSparseNamespace( )
1303         throws Exception
1304     {
1305         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1306         {
1307             String namespace = "org.apache.archiva";
1308             ArtifactMetadata artifact = createArtifact( );
1309             artifact.setNamespace( namespace );
1310             getRepository( ).updateArtifact( session, TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1311             session.save( );
1312
1313             tryAssert( ( ) -> {
1314                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, null );
1315
1316                 tryAssert( ( ) -> assertEquals( Collections.singletonList( artifact ), artifacts ) );
1317             } );
1318         }
1319     }
1320
1321     @Test
1322     public void testGetArtifactsByDateRangeLowerBound( )
1323         throws Exception
1324     {
1325         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1326         {
1327             ArtifactMetadata artifact = createArtifact( );
1328             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1329             session.save( );
1330
1331             ZonedDateTime date = ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())).minusSeconds(10);
1332
1333             tryAssert( ( ) -> {
1334                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, date, null );
1335
1336                 assertEquals( Collections.singletonList( artifact ), artifacts );
1337             } );
1338         }
1339     }
1340
1341     @Test
1342     public void testGetArtifactsByDateRangeLowerBoundOutOfRange( )
1343         throws Exception
1344     {
1345         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1346         {
1347             ArtifactMetadata artifact = createArtifact( );
1348             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1349
1350             ZonedDateTime date = ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())).plusSeconds(10);
1351
1352             tryAssert( ( ) -> {
1353                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, date, null );
1354
1355                 assertThat( artifacts ).isNotNull( ).isEmpty( );
1356             } );
1357         }
1358     }
1359
1360     @Test
1361     public void testGetArtifactsByDateRangeLowerAndUpperBound( )
1362         throws Exception
1363     {
1364         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1365         {
1366             ArtifactMetadata artifact = createArtifact( );
1367             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1368             session.save( );
1369
1370             ZonedDateTime lower = ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())).minusSeconds(10);
1371             ZonedDateTime upper = ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())).plusSeconds(10);
1372
1373             tryAssert( ( ) -> {
1374                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, lower, upper );
1375
1376                 assertEquals( Collections.singletonList( artifact ), artifacts );
1377             } );
1378         }
1379     }
1380
1381     @Test
1382     public void testGetArtifactsByDateRangeUpperBound( )
1383         throws Exception
1384     {
1385         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1386         {
1387             ArtifactMetadata artifact = createArtifact( );
1388             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1389             session.save( );
1390
1391             ZonedDateTime upper = ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())).plusSeconds(10);
1392
1393             tryAssert( ( ) -> {
1394                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, upper );
1395
1396                 assertEquals( Collections.singletonList( artifact ), artifacts );
1397             } );
1398         }
1399     }
1400
1401     @Test
1402     public void testGetArtifactsByDateRangeUpperBoundOutOfRange( )
1403         throws Exception
1404     {
1405         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1406         {
1407             ArtifactMetadata artifact = createArtifact( );
1408             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1409             session.save( );
1410
1411             ZonedDateTime upper = ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())).minusSeconds(10);
1412
1413             tryAssert( ( ) -> {
1414                 List<ArtifactMetadata> artifacts = getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, upper );
1415
1416                 assertThat( artifacts ).isNotNull( ).isEmpty( );
1417             } );
1418         }
1419     }
1420
1421     @Test
1422     public void testGetArtifactsByRepoId( )
1423         throws Exception
1424     {
1425         ArtifactMetadata artifact;
1426         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1427         {
1428             artifact = createArtifact( );
1429             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1430             session.save( );
1431         }
1432         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1433         {
1434             tryAssert( ( ) -> {
1435                     session.refreshAndDiscard( );
1436                     List<ArtifactMetadata> artifacts = getRepository( ).getArtifacts( session, TEST_REPO_ID );
1437                     assertEquals( Collections.singletonList( artifact ), artifacts );
1438                 }
1439             );
1440         }
1441     }
1442
1443     @Test
1444     public void testGetArtifactsByRepoIdMultipleCopies( )
1445         throws Exception
1446     {
1447         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1448         {
1449             ArtifactMetadata artifact = createArtifact( );
1450             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1451
1452             ArtifactMetadata secondArtifact = createArtifact( );
1453             secondArtifact.setRepositoryId( OTHER_REPO_ID );
1454             getRepository( ).updateArtifact( session, OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1455             session.save( );
1456
1457             // test it restricts to the appropriate repository
1458             tryAssert( ( ) -> {
1459                 List<ArtifactMetadata> artifact1 = getRepository( ).getArtifacts( session, TEST_REPO_ID );
1460                 assertEquals( Collections.singletonList( artifact ), artifact1 );
1461                 assertEquals( Collections.singletonList( secondArtifact ), getRepository( ).getArtifacts( session, OTHER_REPO_ID ) );
1462             });
1463
1464         }
1465     }
1466
1467
1468     @Test
1469     public void testGetArtifactsByDateRangeMultipleCopies( )
1470         throws Exception
1471     {
1472         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1473         {
1474             ArtifactMetadata artifact = createArtifact( );
1475             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1476
1477             ArtifactMetadata secondArtifact = createArtifact( );
1478             secondArtifact.setRepositoryId( OTHER_REPO_ID );
1479             getRepository( ).updateArtifact( session, OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1480             session.save( );
1481
1482             tryAssert( ( ) -> {
1483                 // test it restricts to the appropriate repository
1484                 assertEquals( Collections.singletonList( artifact ),
1485                     getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, null ) );
1486             } );
1487             tryAssert( ( ) -> {
1488                 assertEquals( Collections.singletonList( secondArtifact ),
1489                     getRepository( ).getArtifactsByDateRange( session, OTHER_REPO_ID, null, null ) );
1490             } );
1491         }
1492     }
1493
1494     @Test
1495     public void testGetArtifactsByChecksumMultipleCopies( )
1496         throws Exception
1497     {
1498         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1499         {
1500             ArtifactMetadata artifact = createArtifact( );
1501             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1502
1503             ArtifactMetadata secondArtifact = createArtifact( );
1504             secondArtifact.setRepositoryId( OTHER_REPO_ID );
1505             getRepository( ).updateArtifact( session, OTHER_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, secondArtifact );
1506             session.save( );
1507
1508             tryAssert( ( ) -> {
1509                 // test it restricts to the appropriate repository
1510                 assertEquals( Collections.singletonList( artifact ),
1511                     new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_SHA1 ) ) );
1512             } );
1513             tryAssert( ( ) -> {
1514                 assertEquals( Collections.singletonList( secondArtifact ), new ArrayList<>(
1515                     getRepository( ).getArtifactsByChecksum( session, OTHER_REPO_ID, TEST_SHA1 ) ) );
1516             } );
1517             tryAssert( ( ) -> {
1518                 assertEquals( Collections.singletonList( artifact ),
1519                     new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_MD5 ) ) );
1520             } );
1521             tryAssert( ( ) -> {
1522                 assertEquals( Collections.singletonList( secondArtifact ),
1523                     new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, OTHER_REPO_ID, TEST_MD5 ) ) );
1524
1525             } );
1526         }
1527     }
1528
1529     @Test
1530     public void testGetNamespacesWithSparseDepth( )
1531         throws Exception
1532     {
1533         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1534         {
1535             getRepository( ).updateNamespace( session, TEST_REPO_ID, "org.apache.maven.shared" );
1536
1537             tryAssert( ( ) -> {
1538
1539                 Collection<String> namespaces = getRepository( ).getRootNamespaces( session, TEST_REPO_ID );
1540
1541                 assertThat( namespaces ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( "org" );
1542
1543                 namespaces = getRepository( ).getChildNamespaces( session, TEST_REPO_ID, "org" );
1544                 assertThat( namespaces ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( "apache" );
1545
1546                 namespaces = getRepository( ).getChildNamespaces( session, TEST_REPO_ID, "org.apache" );
1547                 assertThat( namespaces ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( "maven" );
1548
1549                 namespaces = getRepository( ).getChildNamespaces( session, TEST_REPO_ID, "org.apache.maven" );
1550                 assertThat( namespaces ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( "shared" );
1551
1552             } );
1553         }
1554     }
1555
1556     @Test
1557     public void testGetNamespacesWithProjectsPresent( )
1558         throws Exception
1559     {
1560         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1561         {
1562             String namespace = "org.apache.maven.shared";
1563             getRepository( ).updateNamespace( session, TEST_REPO_ID, namespace );
1564
1565             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
1566             metadata.setId( TEST_PROJECT_VERSION );
1567             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, namespace, TEST_PROJECT, metadata );
1568
1569             Collection<String> namespaces = getRepository( ).getChildNamespaces( session, TEST_REPO_ID, namespace );
1570
1571             assertThat( namespaces ).isNotNull( ).isEmpty( );
1572
1573
1574         }
1575     }
1576
1577     @Test
1578     public void testGetProjectsWithOtherNamespacesPresent( )
1579         throws Exception
1580     {
1581         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1582         {
1583             ProjectMetadata projectMetadata = new ProjectMetadata( );
1584             projectMetadata.setId( TEST_PROJECT );
1585             projectMetadata.setNamespace( "org.apache.maven" );
1586             getRepository( ).updateProject( session, TEST_REPO_ID, projectMetadata );
1587
1588             getRepository( ).updateNamespace( session, TEST_REPO_ID, "org.apache.maven.shared" );
1589
1590             Collection<String> projects = getRepository( ).getProjects( session, TEST_REPO_ID, "org.apache.maven" );
1591
1592             assertThat( projects ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( TEST_PROJECT );
1593
1594         }
1595     }
1596
1597     @Test
1598     public void testGetProjectVersionsWithOtherNamespacesPresent( )
1599         throws Exception
1600     {
1601         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1602         {
1603 // an unusual case but technically possible where a project namespace matches another project's name
1604
1605             ProjectVersionMetadata versionMetadata = new ProjectVersionMetadata( );
1606             versionMetadata.setId( TEST_PROJECT_VERSION );
1607             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, "org.apache.maven", TEST_PROJECT, versionMetadata );
1608
1609             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT,
1610                 "other-project", versionMetadata );
1611
1612             Collection<String> versions =
1613                 getRepository( ).getProjectVersions( session, TEST_REPO_ID, "org.apache.maven." + TEST_PROJECT, "other-project" );
1614             assertThat( versions ).isNotNull( ).isNotEmpty( ).contains( TEST_PROJECT_VERSION );
1615
1616             versions = getRepository( ).getProjectVersions( session, TEST_REPO_ID, "org.apache.maven", TEST_PROJECT );
1617
1618             assertThat( versions ).isNotNull( ).isNotEmpty( ).contains( TEST_PROJECT_VERSION );
1619
1620         }
1621     }
1622
1623     @Test
1624     public void testGetArtifactsByChecksumSingleResultSha256( )
1625         throws Exception
1626     {
1627         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1628         {
1629             ArtifactMetadata artifact = createArtifact( );
1630             artifact.setChecksum( ChecksumAlgorithm.SHA256,  TEST_SHA256);
1631             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1632             session.save( );
1633
1634             tryAssert( () ->
1635                 assertEquals( Collections.singletonList( artifact ),
1636                 new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_SHA256 ) ))
1637             );
1638
1639         }
1640     }
1641
1642     @Test
1643     public void testGetArtifactsByChecksumSingleResultMd5( )
1644         throws Exception
1645     {
1646         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1647         {
1648             ArtifactMetadata artifact = createArtifact( );
1649             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1650             session.save( );
1651
1652             assertEquals( Collections.singletonList( artifact ),
1653                 new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_MD5 ) ) );
1654
1655         }
1656     }
1657
1658     @Test
1659     public void testGetArtifactsByChecksumSingleResultSha1( )
1660         throws Exception
1661     {
1662         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1663         {
1664             ArtifactMetadata artifact = createArtifact( );
1665             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1666             session.save( );
1667
1668             assertEquals( Collections.singletonList( artifact ),
1669                 new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_SHA1 ) ) );
1670
1671         }
1672     }
1673
1674     @Test
1675     public void testGetArtifactsByChecksumDeepNamespace( )
1676         throws Exception
1677     {
1678         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1679         {
1680             ArtifactMetadata artifact = createArtifact( );
1681             String namespace = "multi.level.ns";
1682             artifact.setNamespace( namespace );
1683             getRepository( ).updateArtifact( session, TEST_REPO_ID, namespace, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1684             session.save( );
1685
1686             tryAssert( ( ) ->
1687             {
1688                 assertEquals( Collections.singletonList( artifact ),
1689                     new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_SHA1 ) ) );
1690                 assertEquals( Collections.singletonList( artifact ),
1691                     new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_MD5 ) ) );
1692             });
1693
1694         }
1695     }
1696
1697     @Test
1698     public void testGetArtifactsByChecksumMultipleResult( )
1699         throws Exception
1700     {
1701
1702         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1703         {
1704             ArtifactMetadata artifact1 = createArtifact( );
1705             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 );
1706
1707             String newProjectId = "another-project";
1708             ArtifactMetadata artifact2 = createArtifact( );
1709             artifact2.setProject( newProjectId );
1710             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, newProjectId, TEST_PROJECT_VERSION, artifact2 );
1711             session.save( );
1712
1713             tryAssert( ( ) -> {
1714                 List<ArtifactMetadata> artifacts =
1715                     new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_SHA1 ) );
1716                 Collections.sort( artifacts, new ArtifactMetadataComparator( ) );
1717                 assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1718             } );
1719
1720             tryAssert( ( ) -> {
1721                 ArrayList<ArtifactMetadata> artifacts = new ArrayList<>( getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, TEST_MD5 ) );
1722                 Collections.sort( artifacts, new ArtifactMetadataComparator( ) );
1723                 assertEquals( Arrays.asList( artifact2, artifact1 ), artifacts );
1724             } );
1725         }
1726     }
1727
1728     @Test
1729     public void testGetArtifactsByChecksumNoResult( )
1730         throws Exception
1731     {
1732         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1733         {
1734             ArtifactMetadata artifact = createArtifact( );
1735             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1736
1737             tryAssert( ( ) -> {
1738                 Collection<ArtifactMetadata> artifactsByChecksum =
1739                     getRepository( ).getArtifactsByChecksum( session, TEST_REPO_ID, "not checksum" );
1740
1741                 assertThat( artifactsByChecksum ).isNotNull( ).isEmpty( );
1742             } );
1743
1744         }
1745     }
1746
1747     @Test
1748     public void testGetArtifactsByProjectVersionMetadata( )
1749         throws Exception
1750     {
1751         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1752         {
1753             createArtifactWithGenericMetadataFacet( session, 10 );
1754
1755             tryAssert( ( ) -> {
1756                 Collection<ArtifactMetadata> artifactsByMetadata =
1757                     getRepository( ).getArtifactsByProjectVersionFacet( session, TEST_METADATA_KEY, TEST_METADATA_VALUE, TEST_REPO_ID );
1758
1759                 assertThat( artifactsByMetadata ).hasSize( 1 );
1760                 ArtifactMetadata artifactMetadata = artifactsByMetadata.iterator( ).next( );
1761                 assertThat( artifactMetadata.getId( ) ).isEqualTo( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
1762                 assertThat( artifactMetadata.getSha1( ) ).isEqualTo( TEST_SHA1 );
1763                 assertThat( artifactMetadata.getRepositoryId( ) ).isEqualTo( TEST_REPO_ID );
1764             } );
1765         }
1766     }
1767
1768     @Test
1769     public void testGetArtifactsByProjectVersionMetadataNoRepository( )
1770         throws Exception
1771     {
1772         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1773         {
1774             createArtifactWithGenericMetadataFacet( session );
1775             tryAssert( ( ) -> {
1776
1777                 Collection<ArtifactMetadata> artifactsByMetadata =
1778                     getRepository( ).getArtifactsByProjectVersionFacet( session, TEST_METADATA_KEY, TEST_METADATA_VALUE, null );
1779                 assertThat( artifactsByMetadata ).hasSize( 1 );
1780                 assertThat( artifactsByMetadata.iterator( ).next( ).getRepositoryId( ) ).isNotNull( ).isNotEmpty( );
1781             } );
1782         }
1783     }
1784
1785     @Test
1786     public void testGetArtifactsByProjectVersionMetadataAllRepositories( )
1787         throws Exception
1788     {
1789         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1790         {
1791             createArtifactWithGenericMetadataFacet( session );
1792             tryAssert( ( ) -> {
1793
1794                 Collection<ArtifactMetadata> artifactsByMetadata =
1795                     getRepository( ).getArtifactsByProjectVersionFacet( session, TEST_METADATA_KEY, TEST_METADATA_VALUE, null );
1796                 assertThat( artifactsByMetadata ).hasSize( 1 );
1797             } );
1798         }
1799     }
1800
1801     @Test
1802     public void testGetArtifactsByMetadataAllRepositories( )
1803         throws Exception
1804     {
1805         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1806         {
1807             createArtifactWithMavenArtifactFacet( session );
1808             tryAssert( ( ) -> {
1809                 Collection<ArtifactMetadata> artifactsByMetadata =
1810                     getRepository( ).getArtifactsByAttribute( session, "foo", TEST_METADATA_VALUE, null );
1811                 assertThat( artifactsByMetadata ).hasSize( 1 );
1812                 ArtifactMetadata artifactMetadata = artifactsByMetadata.iterator( ).next( );
1813                 assertThat( artifactMetadata.getId( ) ).isEqualTo( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
1814                 assertThat( artifactMetadata.getSha1( ) ).isEqualTo( TEST_SHA1 );
1815                 assertThat( artifactMetadata.getRepositoryId( ) ).isEqualTo( TEST_REPO_ID );
1816                 MetadataFacet facet = artifactMetadata.getFacet( TEST_FACET_ID );
1817                 assertThat( facet ).isNotNull( );
1818                 assertThat( facet.toProperties( ).get("foo").equals(TEST_METADATA_VALUE) );
1819             } );
1820         }
1821     }
1822
1823     @Test
1824     public void testGetArtifactsByPropertySingleResult( )
1825         throws Exception
1826     {
1827         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1828         {
1829             createArtifactWithData( session );
1830             // only works on JCR implementation
1831             // Collection<ArtifactMetadata> artifactsByProperty = getRepository().getArtifactsByProjectVersionAttribute( "org.name", TEST_ORGANIZATION.getName(), TEST_REPO_ID );
1832             tryAssert( ( ) -> {
1833
1834                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).getArtifactsByProjectVersionAttribute( session, "url", TEST_URL, TEST_REPO_ID );
1835                 assertThat( artifactsByProperty ).hasSize( 1 );
1836                 ArtifactMetadata artifactMetadata = artifactsByProperty.iterator( ).next( );
1837                 assertThat( artifactMetadata.getId( ) ).isEqualTo( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + ".jar" );
1838                 assertThat( artifactMetadata.getSha1( ) ).isEqualTo( TEST_SHA1 );
1839                 assertThat( artifactMetadata.getRepositoryId( ) ).isEqualTo( TEST_REPO_ID );
1840             } );
1841
1842         }
1843     }
1844
1845     @Test
1846     public void testDeleteRepository( )
1847         throws Exception
1848     {
1849         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1850         {
1851
1852             getRepository( ).updateNamespace( session, TEST_REPO_ID, TEST_NAMESPACE );
1853
1854             ProjectMetadata project1 = new ProjectMetadata( );
1855             project1.setNamespace( TEST_NAMESPACE );
1856             project1.setId( "project1" );
1857             getRepository( ).updateProject( session, TEST_REPO_ID, project1 );
1858             ProjectMetadata project2 = new ProjectMetadata( );
1859             project2.setNamespace( TEST_NAMESPACE );
1860             project2.setId( "project2" );
1861             getRepository( ).updateProject( session, TEST_REPO_ID, project2 );
1862
1863             ArtifactMetadata artifact1 = createArtifact( );
1864             artifact1.setProject( "project1" );
1865             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, "project1", TEST_PROJECT_VERSION, artifact1 );
1866             ArtifactMetadata artifact2 = createArtifact( );
1867             artifact2.setProject( "project2" );
1868             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, "project2", TEST_PROJECT_VERSION, artifact2 );
1869             session.save( );
1870
1871             List<ArtifactMetadata> expected = Arrays.asList( artifact1, artifact2 );
1872             Collections.sort( expected, new ArtifactMetadataComparator( ) );
1873
1874
1875             tryAssert( ( ) -> {
1876                 List<ArtifactMetadata> actual =
1877                     new ArrayList<>( getRepository( ).getArtifactsByDateRange( session, TEST_REPO_ID, null, null ) );
1878                 Collections.sort( actual, new ArtifactMetadataComparator( ) );
1879                 assertEquals( expected, actual );
1880             } );
1881
1882             getRepository( ).removeRepository( session, TEST_REPO_ID );
1883
1884             tryAssert( ( ) -> {
1885                 assertTrue( getRepository( ).getArtifacts( session, TEST_REPO_ID ).isEmpty( ) );
1886                 assertTrue( getRepository( ).getRootNamespaces( session, TEST_REPO_ID ).isEmpty( ) );
1887             } );
1888         }
1889     }
1890
1891
1892     @Test
1893     public void testDeleteArtifact( )
1894         throws Exception
1895     {
1896         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1897         {
1898
1899             ArtifactMetadata artifact = createArtifact( );
1900             artifact.addFacet( new TestMetadataFacet( "value" ) );
1901
1902             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1903
1904             assertThat( getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
1905                 TEST_PROJECT, TEST_PROJECT_VERSION ) ).containsExactly( artifact );
1906
1907             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION_2_0, artifact );
1908
1909             Collection<String> versions = getRepository( ).getProjectVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1910
1911             log.info( "versions {}", versions );
1912
1913             assertThat( versions ).isNotNull( ).isNotEmpty( ).hasSize( 2 ).contains( "1.0", "2.0" );
1914
1915             getRepository( ).removeArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId( ) );
1916
1917             versions = getRepository( ).getProjectVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1918
1919             log.info( "versions {}", versions );
1920
1921             assertThat( versions ).isNotNull( ).isNotEmpty( ).hasSize( 1 ).contains( "2.0" );
1922
1923             assertThat( getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
1924                 TEST_PROJECT, TEST_PROJECT_VERSION ) ).isNotNull( ).isEmpty( );
1925
1926             assertThat( getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE,
1927                 TEST_PROJECT, TEST_PROJECT_VERSION_2_0 ) ).isNotEmpty( ).hasSize( 1 );
1928         }
1929     }
1930
1931     @Test
1932     public void deleteArtifact( )
1933         throws Exception
1934     {
1935         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1936         {
1937             ArtifactMetadata artifact = createArtifact( );
1938             artifact.addFacet( new TestMetadataFacet( "value" ) );
1939
1940             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1941
1942             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1943
1944             tryAssert( ( ) -> {
1945                 Collection<ArtifactMetadata> artifacts =
1946                     getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1947
1948                 assertEquals( Collections.singletonList( artifact ), new ArrayList<>( artifacts ) );
1949
1950             } );
1951
1952             getRepository( ).removeArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact.getId( ) );
1953
1954             tryAssert( ( ) -> {
1955                 Collection<ArtifactMetadata> artifacts = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1956
1957                 assertThat( artifacts ).isNotNull( ).isEmpty( );
1958             } );
1959
1960         }
1961     }
1962
1963     @Test
1964     public void deleteVersion( )
1965         throws Exception
1966     {
1967         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1968         {
1969             ArtifactMetadata artifact = createArtifact( );
1970             artifact.addFacet( new TestMetadataFacet( "value" ) );
1971
1972             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1973
1974             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
1975
1976             tryAssert( ( ) -> {
1977
1978                 Collection<String> versions = getRepository( ).getProjectVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1979
1980                 assertThat( versions ).isNotNull( ).isNotEmpty( ).hasSize( 1 );
1981             } );
1982
1983             getRepository( ).removeProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
1984
1985             tryAssert( ( ) -> {
1986
1987                 Collection<String> versions1 = getRepository( ).getProjectVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
1988
1989                 assertThat( versions1 ).isNotNull( ).isEmpty( );
1990             } );
1991         }
1992     }
1993
1994     @Test
1995     public void deleteProject( )
1996         throws Exception
1997     {
1998         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
1999         {
2000             ArtifactMetadata artifact = createArtifact( );
2001             artifact.addFacet( new TestMetadataFacet( "value" ) );
2002
2003             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
2004
2005             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
2006
2007             assertEquals( 1, getRepository( ).getProjectVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT ).size( ) );
2008
2009             getRepository( ).removeProject( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
2010
2011             Collection<String> versions = getRepository( ).getProjectVersions( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT );
2012
2013             assertThat( versions ).isNotNull( ).isEmpty( );
2014
2015         }
2016     }
2017
2018
2019     @Test
2020     public void deleteSnapshotVersion( )
2021         throws Exception
2022     {
2023         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2024         {
2025
2026             ArtifactMetadata artifactOne = createArtifact( );
2027             artifactOne.setVersion( "2.0-20120618.214127-1" );
2028             artifactOne.setProjectVersion( "2.0-SNAPSHOT" );
2029             artifactOne.addFacet( new TestMetadataFacet( "value" ) );
2030             artifactOne.setId( TEST_PROJECT + "-" + "2.0-20120618.214127-1" + "." + "jar" );
2031
2032             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactOne );
2033
2034             ArtifactMetadata artifactTwo = createArtifact( );
2035             artifactTwo.setVersion( "2.0-20120618.214135-2" );
2036             artifactTwo.setProjectVersion( "2.0-SNAPSHOT" );
2037             artifactTwo.addFacet( new TestMetadataFacet( "value" ) );
2038             artifactTwo.setId( TEST_PROJECT + "-" + "2.0-20120618.214135-2" + "." + "jar" );
2039
2040             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT", artifactTwo );
2041
2042             Collection<ArtifactMetadata> artifactMetadatas =
2043                 getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
2044
2045             assertThat( artifactMetadatas ).isNotNull( ).isNotEmpty( ).hasSize( 2 );
2046
2047             log.info( "artifactMetadatas: {}", artifactMetadatas );
2048
2049             getRepository( ).removeTimestampedArtifact( session, artifactOne, "2.0-SNAPSHOT" );
2050
2051             artifactMetadatas = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
2052
2053             assertThat( artifactMetadatas ).isNotNull( ).isNotEmpty( ).hasSize( 1 );
2054
2055             getRepository( ).removeTimestampedArtifact( session, artifactTwo, "2.0-SNAPSHOT" );
2056
2057             artifactMetadatas = getRepository( ).getArtifacts( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, "2.0-SNAPSHOT" );
2058
2059             assertThat( artifactMetadatas ).isNotNull( ).isEmpty( );
2060         }
2061     }
2062
2063
2064     @Test
2065     public void testgetProjectReferences( )
2066         throws Exception
2067     {
2068         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2069         {
2070
2071             ProjectVersionMetadata metadata = new ProjectVersionMetadata( );
2072             metadata.setId( TEST_PROJECT_VERSION );
2073
2074             metadata.setName( "project name" );
2075             metadata.setDescription( "project description" );
2076             metadata.setUrl( "the url" );
2077
2078             Dependency d = new Dependency( );
2079             d.setArtifactId( "artifactId" );
2080             d.setClassifier( "classifier" );
2081             d.setGroupId( "groupId" );
2082             d.setScope( "scope" );
2083             d.setSystemPath( "system path" );
2084             d.setType( "type" );
2085             d.setVersion( "version" );
2086             d.setOptional( true );
2087             metadata.addDependency( d );
2088
2089             d = new Dependency( );
2090             d.setArtifactId( "artifactId1" );
2091             d.setClassifier( "classifier" );
2092             d.setGroupId( "groupId" );
2093             d.setScope( "scope" );
2094             d.setSystemPath( "system path" );
2095             d.setType( "type" );
2096             d.setVersion( "version1" );
2097             d.setOptional( true );
2098             metadata.addDependency( d );
2099
2100             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
2101
2102             session.save( );
2103
2104             metadata = getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
2105             final Dependency dd = d;
2106
2107
2108             tryAssert( ( ) -> {
2109
2110                 Collection<ProjectVersionReference> references =
2111                     getRepository( ).getProjectReferences( session, TEST_REPO_ID, dd.getGroupId( ), dd.getArtifactId( ), dd.getVersion( ) );
2112                     log.info( "references: {}", references );
2113                 assertThat( references ).isNotNull( ).hasSize( 1 ).contains(
2114                     new ProjectVersionReference( ProjectVersionReference.ReferenceType.DEPENDENCY, TEST_PROJECT, TEST_NAMESPACE,
2115                         TEST_PROJECT_VERSION ));
2116             }
2117             );
2118
2119         }
2120     }
2121
2122     @Test
2123     public void testSearchArtifactsByKey( )
2124         throws Exception
2125     {
2126         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2127         {
2128             createArtifactWithData( session );
2129         }
2130
2131         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2132         {
2133             session.refreshAndDiscard( );
2134             tryAssert( ( ) -> {
2135                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).searchArtifacts( session, TEST_REPO_ID, "url", TEST_URL, false );
2136                 assertThat( artifactsByProperty ).isNotNull( ).isNotEmpty( );
2137             } );
2138         }
2139     }
2140
2141     @Test
2142     public void testSearchArtifactsByKeyExact( )
2143         throws Exception
2144     {
2145         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2146         {
2147             createArtifactWithData( session );
2148         }
2149         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2150         {
2151             session.refreshAndDiscard( );
2152             tryAssert( ( ) -> {
2153                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).searchArtifacts( session, TEST_REPO_ID, "url", TEST_URL, true );
2154                 assertThat( artifactsByProperty ).describedAs( "Artifact search by url=%s must give a result.", TEST_URL ).isNotNull( ).isNotEmpty( );
2155                 artifactsByProperty = getRepository( ).searchArtifacts( session, TEST_REPO_ID, "org.name", "pache", true );
2156                 assertThat( artifactsByProperty ).describedAs( "Artifact search by text org.name='pache' must be empty" ).isNotNull( ).isEmpty( );
2157             } );
2158         }
2159     }
2160
2161     @Test
2162     public void testSearchArtifactsByFacetKey( )
2163         throws Exception
2164     {
2165         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2166         {
2167             createArtifactWithGenericMetadataFacet( session );
2168             tryAssert( ( ) -> {
2169                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).searchArtifacts( session, TEST_REPO_ID, TEST_METADATA_KEY, TEST_METADATA_VALUE, false );
2170                 assertThat( artifactsByProperty ).isNotNull( ).isNotEmpty( );
2171             } );
2172
2173         }
2174     }
2175
2176     @Test
2177     public void testSearchArtifactsByFacetKeyAllRepos( )
2178         throws Exception
2179     {
2180         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2181         {
2182
2183             createArtifactWithGenericMetadataFacet( session );
2184             tryAssert( ( ) -> {
2185                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).searchArtifacts( session, null, TEST_METADATA_KEY, TEST_METADATA_VALUE, false );
2186                 assertThat( artifactsByProperty ).isNotNull( ).isNotEmpty( );
2187             } );
2188         }
2189     }
2190
2191     @Test
2192     public void testSearchArtifactsFullText( )
2193         throws Exception
2194     {
2195         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2196         {
2197             createArtifactWithGenericMetadataFacet( session );
2198             // only works in JCR
2199             // Collection<ArtifactMetadata> artifactsByProperty = getRepository().searchArtifacts( TEST_URL, TEST_REPO_ID, false );
2200             tryAssert( ( ) -> {
2201                 Collection<ArtifactMetadata> artifactsByProperty =
2202                     getRepository( ).searchArtifacts( session, TEST_REPO_ID, TEST_METADATA_VALUE, false );
2203                 assertThat( artifactsByProperty ).isNotNull( ).isNotEmpty( );
2204             } );
2205
2206         }
2207     }
2208
2209     @Test
2210     public void testSearchArtifactsFullTextExact( )
2211         throws Exception
2212     {
2213         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2214         {
2215             createArtifactWithGenericMetadataFacet( session );
2216             // only works in JCR
2217             // Collection<ArtifactMetadata> artifactsByProperty = getRepository().searchArtifacts( TEST_URL, TEST_REPO_ID, true );
2218
2219             tryAssert( ( ) -> {
2220                 Collection<ArtifactMetadata> artifactsByProperty =
2221                     getRepository( ).searchArtifacts( session, TEST_REPO_ID, TEST_METADATA_VALUE, true );
2222                 assertThat( artifactsByProperty ).isNotNull( ).isNotEmpty( );
2223             } );
2224             tryAssert( ( ) -> {
2225
2226                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).searchArtifacts( session, TEST_REPO_ID, TEST_METADATA_VALUE.substring( 2 ), true );
2227                 assertThat( artifactsByProperty ).isNotNull( ).isEmpty( );
2228             } );
2229         }
2230     }
2231
2232     @Test
2233     public void testSearchArtifactsFullTextByFacet( )
2234         throws Exception
2235     {
2236         try ( RepositorySession session = getSessionFactory( ).createSession( ) )
2237         {
2238             createArtifactWithGenericMetadataFacet( session );
2239             tryAssert( ( ) -> {
2240                 Collection<ArtifactMetadata> artifactsByProperty = getRepository( ).searchArtifacts( session, TEST_REPO_ID, TEST_METADATA_VALUE, false );
2241                 assertThat( artifactsByProperty ).isNotNull( ).isNotEmpty( );
2242             } );
2243
2244         }
2245     }
2246
2247     private static ProjectMetadata createProject( )
2248     {
2249         return createProject( TEST_NAMESPACE );
2250     }
2251
2252     private static ProjectMetadata createProject( String ns )
2253     {
2254         ProjectMetadata project = new ProjectMetadata( );
2255         project.setId( TEST_PROJECT );
2256         project.setNamespace( ns );
2257         return project;
2258     }
2259
2260     private void createArtifactWithGenericMetadataFacet( RepositorySession session )
2261         throws MetadataRepositoryException, MetadataResolutionException, MetadataSessionException
2262     {
2263         createArtifactWithGenericMetadataFacet( session, 1 );
2264     }
2265
2266     private void createArtifactWithGenericMetadataFacet( RepositorySession session, int artifacts )
2267         throws MetadataRepositoryException, MetadataResolutionException, MetadataSessionException
2268     {
2269         MetadataFacet metadataFacet = new GenericMetadataFacet( );
2270         Map<String, String> properties = new HashMap<>( );
2271         properties.put( TEST_METADATA_KEY, TEST_METADATA_VALUE );
2272         metadataFacet.fromProperties( properties );
2273         createArtifactWithFacet( session, artifacts, null, metadataFacet );
2274     }
2275
2276     private void createArtifactWithMavenArtifactFacet( RepositorySession session )
2277         throws MetadataRepositoryException, MetadataResolutionException, MetadataSessionException
2278     {
2279         createArtifactWithMavenArtifactFacet( session, 1 );
2280     }
2281
2282     private void createArtifactWithMavenArtifactFacet( RepositorySession session, int artifacts )
2283         throws MetadataRepositoryException, MetadataResolutionException, MetadataSessionException
2284     {
2285         TestMetadataFacet facet = new TestMetadataFacet( TEST_METADATA_VALUE );
2286         createArtifactWithFacet( session, artifacts, facet, null );
2287     }
2288
2289     private void createArtifactWithFacet( RepositorySession session, int artifacts, MetadataFacet artifactFacet,
2290                                           MetadataFacet projectVersionMetadataFacet )
2291         throws MetadataRepositoryException, MetadataResolutionException, MetadataSessionException
2292     {
2293         for ( int i = 0; i < artifacts; i++ )
2294         {
2295             ArtifactMetadata artifact = createArtifact( );
2296             if ( artifactFacet != null )
2297             {
2298                 artifact.addFacet( artifactFacet );
2299             }
2300             getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
2301         }
2302         if ( projectVersionMetadataFacet != null )
2303         {
2304             ProjectVersionMetadata metadata =
2305                 getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
2306             metadata.addFacet( projectVersionMetadataFacet );
2307             metadata.setOrganization( TEST_ORGANIZATION );
2308             metadata.setUrl( TEST_URL );
2309             getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
2310         }
2311         session.save( );
2312     }
2313
2314     protected void createArtifactWithData( RepositorySession session )
2315         throws MetadataRepositoryException, MetadataResolutionException, MetadataSessionException
2316     {
2317         ArtifactMetadata artifact = createArtifact( );
2318         getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact );
2319         ProjectVersionMetadata metadata =
2320             getRepository( ).getProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION );
2321         metadata.setOrganization( TEST_ORGANIZATION );
2322         metadata.setUrl( TEST_URL );
2323
2324         getRepository( ).updateProjectVersion( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, metadata );
2325         session.save( );
2326     }
2327
2328     private static ArtifactMetadata createArtifact( )
2329     {
2330         return createArtifact( "jar" );
2331     }
2332
2333     private static ArtifactMetadata createArtifact( String type )
2334     {
2335         ArtifactMetadata artifact = new ArtifactMetadata( );
2336         artifact.setId( TEST_PROJECT + "-" + TEST_PROJECT_VERSION + "." + type );
2337         artifact.setWhenGathered( ZonedDateTime.now() );
2338         artifact.setNamespace( TEST_NAMESPACE );
2339         artifact.setProject( TEST_PROJECT );
2340         artifact.setRepositoryId( TEST_REPO_ID );
2341         artifact.setFileLastModified( System.currentTimeMillis( ) );
2342         artifact.setVersion( TEST_PROJECT_VERSION );
2343         artifact.setProjectVersion( TEST_PROJECT_VERSION );
2344         artifact.setMd5( TEST_MD5 );
2345         artifact.setSha1( TEST_SHA1 );
2346         return artifact;
2347     }
2348
2349     private static class ArtifactMetadataComparator
2350         implements Comparator<ArtifactMetadata>
2351     {
2352         @Override
2353         public final int compare( ArtifactMetadata a, ArtifactMetadata b )
2354         {
2355             return a.getProject( ).compareTo( b.getProject( ) );
2356         }
2357     }
2358
2359     private static class KindOfRepositoryStatistics
2360         implements MetadataFacet
2361     {
2362         private String value;
2363
2364         private Date date;
2365
2366         static final String SCAN_TIMESTAMP_FORMAT = "yyyy/MM/dd/HHmmss.SSS";
2367
2368         private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );
2369
2370         private KindOfRepositoryStatistics( String value, Date date )
2371         {
2372             this.value = value;
2373             this.date = date;
2374         }
2375
2376         @Override
2377         public String getName( )
2378         {
2379             return createNameFormat( ).format( date );
2380         }
2381
2382         private static SimpleDateFormat createNameFormat( )
2383         {
2384             SimpleDateFormat fmt = new SimpleDateFormat( SCAN_TIMESTAMP_FORMAT );
2385             fmt.setTimeZone( UTC_TIME_ZONE );
2386             return fmt;
2387         }
2388
2389         @Override
2390         public String getFacetId( )
2391         {
2392             return KindOfRepositoryStatistics.class.getName( );
2393         }
2394
2395         @Override
2396         public Map<String, String> toProperties( )
2397         {
2398             return Collections.emptyMap( );
2399         }
2400
2401         @Override
2402         public void fromProperties( Map<String, String> properties )
2403         {
2404             // no op
2405         }
2406     }
2407
2408     private static class TestMetadataFacet
2409         implements MetadataFacet
2410     {
2411         private String testFacetId;
2412
2413         private Map<String, String> additionalProps;
2414
2415         private String value;
2416
2417         private String name = TEST_NAME;
2418
2419         private TestMetadataFacet( String value )
2420         {
2421             this.value = value;
2422             testFacetId = TEST_FACET_ID;
2423         }
2424
2425
2426
2427         private TestMetadataFacet( String facetId, String value )
2428         {
2429             this.value = value;
2430             testFacetId = facetId;
2431         }
2432
2433         private TestMetadataFacet( String facetId, String value, String name)
2434         {
2435             this.value = value;
2436             testFacetId = facetId;
2437             this.name = name;
2438         }
2439
2440         private TestMetadataFacet( String facetId, String value, String name, Map<String, String> additionalProps )
2441         {
2442             this( facetId, value, name );
2443             this.additionalProps = additionalProps;
2444
2445         }
2446
2447         private TestMetadataFacet( String facetId, String value, Map<String, String> additionalProps )
2448         {
2449             this( facetId, value );
2450             this.additionalProps = additionalProps;
2451         }
2452
2453         @Override
2454         public String getFacetId( )
2455         {
2456             return testFacetId;
2457         }
2458
2459         @Override
2460         public String getName( )
2461         {
2462             return name;
2463         }
2464
2465         @Override
2466         public Map<String, String> toProperties( )
2467         {
2468             if ( value != null )
2469             {
2470                 if ( additionalProps == null )
2471                 {
2472                     return Collections.singletonMap( "foo", value );
2473                 }
2474                 else
2475                 {
2476                     Map<String, String> props = new HashMap<>( );
2477                     props.put( "foo", value );
2478
2479                     for ( String key : additionalProps.keySet( ) )
2480                     {
2481                         props.put( key, additionalProps.get( key ) );
2482                     }
2483                     return props;
2484                 }
2485             }
2486             else
2487             {
2488                 return Collections.emptyMap( );
2489             }
2490         }
2491
2492         @Override
2493         public void fromProperties( Map<String, String> properties )
2494         {
2495             String value = properties.get( "foo" );
2496             if ( value != null )
2497             {
2498                 this.value = value;
2499             }
2500
2501             properties.remove( "foo" );
2502
2503             if ( additionalProps == null )
2504             {
2505                 additionalProps = new HashMap<>( );
2506             }
2507
2508             for ( String key : properties.keySet( ) )
2509             {
2510                 additionalProps.put( key, properties.get( key ) );
2511             }
2512         }
2513
2514         public String getValue( )
2515         {
2516             return value;
2517         }
2518
2519         @Override
2520         public String toString( )
2521         {
2522             return "TestMetadataFacet{ name='"+ name+ "' value='" + value + '\'' + '}';
2523         }
2524
2525         @Override
2526         public boolean equals( Object o )
2527         {
2528             if ( this == o )
2529             {
2530                 return true;
2531             }
2532             if ( o == null || getClass( ) != o.getClass( ) )
2533             {
2534                 return false;
2535             }
2536
2537             TestMetadataFacet that = (TestMetadataFacet) o;
2538
2539             if ( value != null ? !value.equals( that.value ) : that.value != null )
2540             {
2541                 return false;
2542             }
2543
2544             return true;
2545         }
2546
2547         @Override
2548         public int hashCode( )
2549         {
2550             return value != null ? value.hashCode( ) : 0;
2551         }
2552     }
2553 }