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