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