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

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