com.google.common.base.Equivalence.Wrapper#org.sonatype.nexus.repository.types.GroupType源码实例Demo

@Before
public void setUp() throws Exception {
  AttributesMap attributesMap = new AttributesMap();
  attributesMap.set(CONTENT_LAST_MODIFIED, DateTime.now());

  when(originalContent.getAttributes()).thenReturn(attributesMap);

  underTest = new OrientPyPiGroupFacet(repositoryManager, constraintViolationFactory, new GroupType()) {
    @Override
    public boolean isStale(@Nullable final Content content) {
      return false;
    }
  };

  responses = ImmutableMap.of(repository, response);
}
 

private void blobStoreIntegrityCheck(final boolean integrityCheck, final String blobStoreId) {
  if (!integrityCheck) {
    log.warn("Integrity check operation not selected");
    return;
  }

  BlobStore blobStore = blobStoreManager.get(blobStoreId);

  if (blobStore == null) {
    log.error("Unable to find blob store '{}' in the blob store manager", blobStoreId);
    return;
  }

  StreamSupport.stream(repositoryManager.browseForBlobStore(blobStoreId).spliterator(), false)
      .filter(r -> !(r.getType() instanceof GroupType))
      .forEach(repository -> integrityCheckStrategies
          .getOrDefault(repository.getFormat().getValue(), defaultIntegrityCheckStrategy)
          .check(repository, blobStore, this::isCanceled, this::integrityCheckFailedHandler)
      );
}
 

@Inject
public BrowseServiceImpl(@Named(GroupType.NAME) final Type groupType,
                         final ComponentEntityAdapter componentEntityAdapter,
                         final VariableResolverAdapterManager variableResolverAdapterManager,
                         final ContentPermissionChecker contentPermissionChecker,
                         final AssetEntityAdapter assetEntityAdapter,
                         final BrowseAssetIterableFactory browseAssetIterableFactory,
                         final BrowseAssetsSqlBuilder browseAssetsSqlBuilder,
                         final BrowseComponentsSqlBuilder browseComponentsSqlBuilder,
                         final BucketStore bucketStore,
                         final RepositoryManager repositoryManager)
{
  this.groupType = checkNotNull(groupType);
  this.componentEntityAdapter = checkNotNull(componentEntityAdapter);
  this.variableResolverAdapterManager = checkNotNull(variableResolverAdapterManager);
  this.contentPermissionChecker = checkNotNull(contentPermissionChecker);
  this.assetEntityAdapter = checkNotNull(assetEntityAdapter);
  this.browseAssetIterableFactory = checkNotNull(browseAssetIterableFactory);
  this.browseAssetsSqlBuilder = checkNotNull(browseAssetsSqlBuilder);
  this.browseComponentsSqlBuilder = checkNotNull(browseComponentsSqlBuilder);
  this.bucketStore = checkNotNull(bucketStore);
  this.repositoryManager = checkNotNull(repositoryManager);
}
 

@Before
public void setup() {
  results = asList(assetOne, assetTwo);

  when(queryOptions.getContentAuth()).thenReturn(true);

  when(assetOneORID.toString()).thenReturn("assetOne");
  when(componentOneORID.toString()).thenReturn("componentOne");

  when(mavenReleases.facet(StorageFacet.class)).thenReturn(storageFacet);
  when(mavenReleases.getName()).thenReturn("releases");
  when(mavenReleases.getFormat()).thenReturn(format);
  when(format.getValue()).thenReturn("maven2");

  when(storageFacet.txSupplier()).thenReturn(txSupplier);
  when(txSupplier.get()).thenReturn(storageTx);

  browseAssetsSqlBuilder = new BrowseAssetsSqlBuilder(assetEntityAdapter);
  browseComponentsSqlBuilder = new BrowseComponentsSqlBuilder(componentEntityAdapter);

  underTest = spy(new BrowseServiceImpl(new GroupType(), componentEntityAdapter, variableResolverAdapterManager,
      contentPermissionChecker, assetEntityAdapter, browseAssetIterableFactory, browseAssetsSqlBuilder,
      browseComponentsSqlBuilder, bucketStore, repositoryManager));
}
 

@Test
public void testGetAssetById_withEntityId_groupRepository() {
  EntityId assetId = new DetachedEntityId(assetOneORID.toString());
  EntityId bucketId = mock(EntityId.class);
  Bucket bucket = mock(Bucket.class);

  when(storageTx.findAsset(assetId)).thenReturn(assetOne);
  when(assetOne.bucketId()).thenReturn(bucketId);
  when(bucketStore.getById(bucketId)).thenReturn(bucket);
  when(bucket.getRepositoryName()).thenReturn("releases");

  Repository groupRepository = mock(Repository.class);
  when(groupRepository.getType()).thenReturn(new GroupType());
  when(groupRepository.getName()).thenReturn("group-repository");
  when(groupRepository.facet(StorageFacet.class)).thenReturn(storageFacet);
  GroupFacet groupFacet = mock(GroupFacet.class);
  when(groupFacet.allMembers()).thenReturn(Arrays.asList(groupRepository, mavenReleases));
  when(groupRepository.facet(GroupFacet.class)).thenReturn(groupFacet);

  when(assetEntityAdapter.readEntity(assetOneDoc)).thenReturn(assetOne);

  assertThat(underTest.getAssetById(assetId, groupRepository), is(assetOne));
  verify(groupFacet).allMembers();
}
 

private void setupMocksForBrowserComponentAssets(boolean allowAssetOne, boolean allowAssetTwo) {
  Repository groupRepository = mock(Repository.class);
  when(groupRepository.getType()).thenReturn(new GroupType());
  when(groupRepository.getName()).thenReturn("group-repository");
  when(groupRepository.facet(StorageFacet.class)).thenReturn(storageFacet);
  GroupFacet groupFacet = mock(GroupFacet.class);
  when(groupFacet.allMembers()).thenReturn(Arrays.asList(groupRepository, mavenReleases));
  when(groupRepository.facet(GroupFacet.class)).thenReturn(groupFacet);
  when(storageTx.findComponent(new DetachedEntityId(componentOneORID.toString()))).thenReturn(componentOne);
  when(repositoryManager.findContainingGroups(mavenReleases.getName())).thenReturn(Collections.singletonList("group-repository"));
  AssetVariableResolver assetVariableResolver = mock(AssetVariableResolver.class);
  when(variableResolverAdapterManager.get(componentOne.format())).thenReturn(assetVariableResolver);
  VariableSource variableSourceOne = createVariableSource(assetOne);
  VariableSource variableSourceTwo = createVariableSource(assetTwo);
  when(assetVariableResolver.fromAsset(assetOne)).thenReturn(variableSourceOne);
  when(assetVariableResolver.fromAsset(assetTwo)).thenReturn(variableSourceTwo);
  when(storageTx.browseAssets(componentOne)).thenReturn(Arrays.asList(assetOne, assetTwo));
  when(contentPermissionChecker
      .isPermitted(eq(Stream.of(mavenReleases.getName(), "group-repository").collect(Collectors.toSet())), any(),
          any(), eq(variableSourceOne))).thenReturn(allowAssetOne);
  when(contentPermissionChecker
      .isPermitted(eq(Stream.of(mavenReleases.getName(), "group-repository").collect(Collectors.toSet())), any(),
          any(), eq(variableSourceTwo))).thenReturn(allowAssetTwo);
}
 

@Override
public AbstractApiRepository adapt(final Repository repository) {
  boolean online = repository.getConfiguration().isOnline();
  String name = repository.getName();
  String format = repository.getFormat().toString();
  String url = repository.getUrl();

  switch (repository.getType().toString()) {
    case GroupType.NAME:
      return new SimpleApiGroupRepository(name, format, url, online, getStorageAttributes(repository),
          getGroupAttributes(repository));
    case HostedType.NAME:
      return new SimpleApiHostedRepository(name, format, url, online, getHostedStorageAttributes(repository),
          getCleanupPolicyAttributes(repository));
    case ProxyType.NAME:
      return new SimpleApiProxyRepository(name, format, url, online, getStorageAttributes(repository),
          getCleanupPolicyAttributes(repository), getProxyAttributes(repository),
          getNegativeCacheAttributes(repository), getHttpClientAttributes(repository),
          getRoutingRuleName(repository));
    default:
      return null;
  }
}
 

@Before
public void setUp() {
  when(rFormat.getValue()).thenReturn(R_FORMAT);
  rHostedRecipe = new RHostedRecipe(new HostedType(), rFormat);
  rProxyRecipe = new RProxyRecipe(new ProxyType(), rFormat);
  rGroupRecipe = new RGroupRecipe(new GroupType(), rFormat);
  rHostedRecipe.setHighAvailabilitySupportChecker(highAvailabilitySupportChecker);
  rProxyRecipe.setHighAvailabilitySupportChecker(highAvailabilitySupportChecker);
  rGroupRecipe.setHighAvailabilitySupportChecker(highAvailabilitySupportChecker);
}
 

@Test
public void createGroup() throws Exception {
  AbstractRepositoryApiRequest request = createGroupRequest(true);

  Response response = post(getCreateRepositoryPathUrl(GroupType.NAME), request);
  assertEquals(Status.CREATED.getStatusCode(), response.getStatus());

  repositoryManager.delete(request.getName());
}
 

@Test
public void createGroup_noMembers() throws Exception {
  RGroupRepositoryApiRequest request = createGroupRequest(true);
  request.getGroup().getMemberNames().clear();

  Response response = post(getCreateRepositoryPathUrl(GroupType.NAME), request);
  assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus());

  assertNull(repositoryManager.get(GROUP_NAME));
}
 

@Test
public void createGroup_mixedMembersFormat() throws Exception {
  RGroupRepositoryApiRequest request = createGroupRequest(true);
  request.getGroup().getMemberNames().add(HOSTED_NAME);

  Response response = post(getCreateRepositoryPathUrl(GroupType.NAME), request);
  assertEquals(Status.BAD_REQUEST.getStatusCode(), response.getStatus());

  assertNull(repositoryManager.get(GROUP_NAME));
}
 

@Test
public void createGroup_noAuthc() throws Exception {
  setBadCredentials();
  AbstractRepositoryApiRequest request = createGroupRequest(true);

  Response response = post(getCreateRepositoryPathUrl(GroupType.NAME), request);
  assertEquals(Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
}
 

@Test
public void createGroup_noAuthz() throws Exception {
  setUnauthorizedUser();
  AbstractRepositoryApiRequest request = createGroupRequest(true);

  Response response = post(getCreateRepositoryPathUrl(GroupType.NAME), request);
  assertEquals(Status.FORBIDDEN.getStatusCode(), response.getStatus());
}
 

@Test
public void updateGroup() throws Exception {
  repos.createRHosted(HOSTED2_NAME);
  repos.createRGroup(GROUP_NAME, HOSTED2_NAME);
  GroupRepositoryApiRequest request = createGroupRequest(false);

  Response response = put(getUpdateRepositoryPathUrl(GroupType.NAME, GROUP_NAME), request);
  assertEquals(Status.NO_CONTENT.getStatusCode(), response.getStatus());

  repositoryManager.delete(HOSTED2_NAME);
  repositoryManager.delete(GROUP_NAME);
}
 

@Test
public void updateGroup_noAuthc() throws Exception {
  repos.createRHosted(HOSTED2_NAME);
  repos.createRGroup(GROUP_NAME, HOSTED2_NAME);
  setBadCredentials();
  GroupRepositoryApiRequest request = createGroupRequest(false);

  Response response = post(getUpdateRepositoryPathUrl(GroupType.NAME, GROUP_NAME), request);
  assertEquals(Status.UNAUTHORIZED.getStatusCode(), response.getStatus());

  repositoryManager.delete(HOSTED2_NAME);
  repositoryManager.delete(GROUP_NAME);
}
 

@Test
public void updateGroup_noAuthz() throws Exception {
  repos.createRHosted(HOSTED2_NAME);
  repos.createRGroup(GROUP_NAME, HOSTED2_NAME);
  setUnauthorizedUser();
  GroupRepositoryApiRequest request = createGroupRequest(false);

  Response response = put(getUpdateRepositoryPathUrl(GroupType.NAME, GROUP_NAME), request);
  assertEquals(Status.FORBIDDEN.getStatusCode(), response.getStatus());

  repositoryManager.delete(HOSTED2_NAME);
  repositoryManager.delete(GROUP_NAME);
}
 

@GET
@Path("/preview")
@RequiresPermissions("nexus:*")
@RequiresAuthentication
public RoutingRulePreviewXO getRoutingRulesPreview(@QueryParam("path") final String path,
                                                   @QueryParam("filter") final String filter)
{
  Map<Class<?>, List<Repository>> repositoriesByType = stream(repositoryManager.browse())
      .collect(groupingBy(r -> r.getType().getClass()));
  List<Repository> groupRepositories = repositoriesByType.get(GroupType.class);
  List<Repository> proxyRepositories = repositoriesByType.get(ProxyType.class);

  Map<RoutingRule, Boolean> routingRulePathMapping = routingRuleStore.list().stream()
      .collect(toMap(identity(), (RoutingRule rule) -> routingRuleHelper.isAllowed(rule, path)));

  final Stream<Repository> repositories;
  if (GROUPS.equals(filter)) {
    repositories = groupRepositories.stream();
  }
  else if (PROXIES.equals(filter)) {
    repositories = proxyRepositories.stream();
  }
  else {
    repositories = Stream.of(groupRepositories, proxyRepositories).flatMap(Collection::stream);
  }

  List<RoutingRulePreviewXO> rootRepositories = repositories.map(repository -> {
    List<Repository> children = repository.optionalFacet(GroupFacet.class)
        .map(facet -> facet.members()).orElse(null);
    return toPreviewXO(repository, children, routingRulePathMapping);
  }).collect(toList());

  return RoutingRulePreviewXO.builder().children(rootRepositories).expanded(!rootRepositories.isEmpty()).expandable(true).build();
}
 

@Inject
public OrientNpmGroupFacet(
    @Named("${nexus.npm.mergeGroupMetadata:-true}") final boolean mergeMetadata,
    final RepositoryManager repositoryManager,
    final ConstraintViolationFactory constraintViolationFactory,
    @Named(GroupType.NAME) final Type groupType)
{
  super(repositoryManager, constraintViolationFactory, groupType);
  this.mergeMetadata = mergeMetadata;
}
 

private AuditRepositoryComponent download(final AuditComponent auditComponent) throws TarballLoadingException {
  checkNotNull(auditComponent);
  String packageName = auditComponent.getName();
  String packageVersion = auditComponent.getVersion();
  String repositoryPath = NpmMetadataUtils.createRepositoryPath(packageName, packageVersion);
  final Request request = new Request.Builder()
      .action(GET)
      .path("/" + repositoryPath)
      .build();
  Repository repository = getRepository();
  Context context = new Context(repository, request);
  Matcher tarballMatcher = tarballMatcher(GET)
      .handler(new EmptyHandler()).create().getMatcher();
  tarballMatcher.matches(context);
  context.getAttributes().set(ProxyTarget.class, TARBALL);

  Optional<String> hashsumOpt;
  String repositoryType = repository.getType().getValue();
  if (repositoryType.equals(GroupType.NAME)) {
    hashsumOpt = tarballGroupHandler.getTarballHashsum(context);
  }
  else if (repositoryType.equals(ProxyType.NAME)) {
    hashsumOpt = getComponentHashsumForProxyRepo(repository, context);
  }
  else {
    // for an npm-hosted repository is no way to get npm package hashsum info.
    String errorMsg = String.format("The %s repository is not supported", repositoryType);
    throw new UnsupportedOperationException(errorMsg);
  }
  String hashsum = hashsumOpt.orElseThrow(() ->
      new TarballLoadingException(String.format("Can't get hashsum for the %s package", auditComponent)));
  return new AuditRepositoryComponent(auditComponent.getPackageType(), repositoryPath, hashsum);
}
 

@Before
public void setup() throws Exception {
  initialiseRepository(npmHosted, new HostedType(), new NpmFormat());
  initialiseRepository(npmProxy, new ProxyType(), new NpmFormat());
  initialiseRepository(npmGroup, new GroupType(), new NpmFormat());
  initialiseRepository(nonNpmFormat, new HostedType(), new Format("non-npm") { });
}
 

@Inject
public OrientPyPiGroupFacet(final RepositoryManager repositoryManager,
                      final ConstraintViolationFactory constraintViolationFactory,
                      @Named(GroupType.NAME) final Type groupType)
{
  super(repositoryManager, constraintViolationFactory, groupType);
}
 

@Test
public void whenCacheTokenOsInvalidShouldBeStale() {
  underTest = new OrientPyPiGroupFacet(repositoryManager, constraintViolationFactory, new GroupType()) {
    @Override
    protected boolean isStale(@Nullable final Content content) {
      return true;
    }
  };

  assertTrue(underTest.isStale(null, originalContent, ImmutableMap.of()));
}
 

@Inject
public PurgeMavenUnusedSnapshotsTask(@Named(GroupType.NAME) final Type groupType,
                                     @Named(HostedType.NAME) final Type hostedType,
                                     @Named(Maven2Format.NAME) final Format maven2Format)
{
  this.groupType = checkNotNull(groupType);
  this.hostedType = checkNotNull(hostedType);
  this.maven2Format = checkNotNull(maven2Format);
}
 

@Inject
public PurgeUnusedSnapshotsFacetImpl(
    final ComponentEntityAdapter componentEntityAdapter,
    @Named(GroupType.NAME) final Type groupType,
    @Named(HostedType.NAME) final Type hostedType,
    @Named("${nexus.tasks.purgeUnusedSnapshots.findUnusedLimit:-50}") int findUnusedLimit)
{
  this.componentEntityAdapter = checkNotNull(componentEntityAdapter);
  this.groupType = checkNotNull(groupType);
  this.hostedType = checkNotNull(hostedType);
  this.findUnusedLimit = findUnusedLimit;
  checkArgument(findUnusedLimit >= 10 && findUnusedLimit <= 1000,
      "nexus.tasks.purgeUnusedSnapshots.findUnusedLimit must be between 10 and 1000");
}
 

@Inject
public RemoveSnapshotsFacetImpl(
    final ComponentEntityAdapter componentEntityAdapter,
    @Named(GroupType.NAME) final Type groupType,
    @Named("${nexus.removeSnapshots.batchSize:-500}") long batchSize)
{
  this.componentEntityAdapter = checkNotNull(componentEntityAdapter);
  this.groupType = checkNotNull(groupType);
  this.batchSize = batchSize;
}
 

@Inject
public OrientMavenGroupFacet(
    final RepositoryManager repositoryManager,
    final ConstraintViolationFactory constraintViolationFactory,
    @Named(GroupType.NAME) final Type groupType)
{
  super(repositoryManager, constraintViolationFactory, groupType);
  this.repositoryMetadataMerger = new RepositoryMetadataMerger();
  this.archetypeCatalogMerger = new ArchetypeCatalogMerger();
}
 

@Before
public void setUp() throws Exception {
  configuration = new TaskConfiguration();
  configuration.setId("test");
  configuration.setTypeId("test");
  configuration.setString(RepositoryTaskSupport.REPOSITORY_NAME_FIELD_ID, ALL_REPOSITORIES);

  when(mavenFacet.getVersionPolicy()).thenReturn(VersionPolicy.SNAPSHOT);

  taskUnderTest = new TestRemoveSnapshotsTask(new Maven2Format());
  taskUnderTest.install(repositoryManager, new GroupType());
  taskUnderTest.configure(configuration);
}
 

private Repository mockGroup(List<Repository> groupMembers) {
  Repository group = mock(Repository.class);
  GroupFacet facet = mock(GroupFacet.class);

  when(group.getName()).thenReturn("");
  when(group.getType()).thenReturn(new GroupType());
  when(group.facet(GroupFacet.class)).thenReturn(facet);
  when(group.getFormat()).thenReturn(new Maven2Format());
  when(group.facet(MavenFacet.class)).thenReturn(mavenFacet);
  when(group.facet(RemoveSnapshotsFacet.class)).thenReturn(removeSnapshotsFacet);
  when(group.optionalFacet(RemoveSnapshotsFacet.class)).thenReturn(Optional.of(removeSnapshotsFacet));
  when(facet.members()).thenReturn(groupMembers);

  return group;
}
 

@Test
public void testAdapt_groupRepository() throws Exception {
  // No maven specific props so simple smoke test
  Repository repository = createRepository(new GroupType());
  repository.getConfiguration().attributes("group").set("memberNames", Arrays.asList("a", "b"));

  SimpleApiGroupRepository groupRepository = (SimpleApiGroupRepository) underTest.adapt(repository);
  assertRepository(groupRepository, "group", true);
}
 

@Test
public void testIntegrityCheck_SkipGroupRepositories() throws Exception {
  configuration.setBoolean(RESTORE_BLOBS, false);
  configuration.setBoolean(UNDELETE_BLOBS, false);
  configuration.setBoolean(INTEGRITY_CHECK, true);
  underTest.configure(configuration);

  when(repository.getType()).thenReturn(new GroupType());
  when(repositoryManager.browseForBlobStore(any())).thenReturn(singletonList(repository));

  underTest.execute();

  verifyZeroInteractions(integrityCheckStrategies);
}