org.sonatype.nexus.repository.types.HostedType Java Examples

@Test
public void onlyRepairNpmHostedRepositories() {
  when(repositoryManager.browse()).thenReturn(ImmutableList.of(npmHosted, npmProxy, npmGroup, nonNpmFormat));

  List<Repository> repairedRepositories = new ArrayList<>();

  NpmRepairPackageRootComponent repairComponent = new NpmRepairPackageRootComponent(repositoryManager,
      assetEntityAdapter, npmPackageParser, new HostedType(), new NpmFormat())
  {
    @Override
    protected void beforeRepair(final Repository repository) {
      repairedRepositories.add(repository);
    }
  };

  repairComponent.repair();

  assertThat(repairedRepositories, is(equalTo(ImmutableList.of(npmHosted))));
}
 

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

  switch (repository.getType().toString()) {
    case HostedType.NAME:
      return new AptHostedApiRepository(name, url, online, getHostedStorageAttributes(repository),
          getCleanupPolicyAttributes(repository), createAptHostedRepositoriesAttributes(repository),
          createAptSigningRepositoriesAttributes(repository));
    case ProxyType.NAME:
      return new AptProxyApiRepository(name, url, online, getHostedStorageAttributes(repository),
          getCleanupPolicyAttributes(repository), createAptProxyRepositoriesAttributes(repository),
          getProxyAttributes(repository), getNegativeCacheAttributes(repository),
          getHttpClientAttributes(repository), getRoutingRuleName(repository));
  }
  return null;
}
 

private UploadHandler getUploadHandler(final Repository repository)
{
  if (!(repository.getType() instanceof HostedType)) {
    throw new ValidationErrorsException(
        format("Uploading components to a '%s' type repository is unsupported, must be '%s'",
            repository.getType().getValue(), HostedType.NAME));
  }

  String repositoryFormat = repository.getFormat().toString();
  UploadHandler uploadHandler = uploadHandlers.get(repositoryFormat);

  if (uploadHandler == null) {
    throw new ValidationErrorsException(
        format("Uploading components to '%s' repositories is unsupported", repositoryFormat));
  }

  return uploadHandler;
}
 

@Before
public void setup() {
  when(handlerA.getDefinition()).thenReturn(uploadA);
  when(handlerB.getDefinition()).thenReturn(uploadB);
  when(handlerA.getValidatingComponentUpload(componentUploadCaptor.capture())).thenReturn(validatingComponentUpload);
  when(handlerB.getValidatingComponentUpload(componentUploadCaptor.capture())).thenReturn(validatingComponentUpload);
  when(validatingComponentUpload.getComponentUpload()).thenAnswer(i -> componentUploadCaptor.getValue());

  when(repository.getFormat()).thenReturn(new Format("a")
  {
  });
  when(repository.getType()).thenReturn(new HostedType());
  when(repository.getConfiguration()).thenReturn(configuration);
  when(configuration.isOnline()).thenReturn(true);

  Map<String, UploadHandler> handlers = new HashMap<>();
  handlers.put("a", handlerA);
  handlers.put("b", handlerB);

  underTest = new UploadManagerImpl(handlers, blobStoreAwareMultipartHelper,
      Collections.singleton(componentUploadExtension));
}
 

@Before
public void setup() throws Exception {
  underTest = Guice.createInjector(new TransactionModule(), new AbstractModule()
  {
    @Override
    protected void configure() {
      bind(EventManager.class).toInstance(eventManager);
      bind(MavenMetadataContentValidator.class).toInstance(mavenMetadataContentValidator);
      bind(MetadataRebuilder.class).toInstance(metadataRebuilder);
      bindConstant().annotatedWith(named("${nexus.maven.metadata.validation.enabled:-true}")).to(true);
      bind(new TypeLiteral<Map<String, MavenPathParser>>() { })
          .toInstance(ImmutableMap.of(Maven2Format.NAME, maven2MavenPathParser));
    }
  }).getInstance(MavenFacetImpl.class);

  underTest.attach(repository);
  when(repository.getType()).thenReturn(new HostedType());
  when(repository.facet(StorageFacet.class)).thenReturn(storageFacet);
  when(storageFacet.txSupplier()).thenReturn(() -> storageTx);

  UnitOfWork.begin(() -> storageTx);
}
 

@Test
public void updateHosted() throws Exception {
  repos.createRHosted(HOSTED_NAME);

  AbstractRepositoryApiRequest request = createHostedRequest(false);

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

  Repository repository = repositoryManager.get(request.getName());
  assertNotNull(repository);

  assertThat(repository.getConfiguration().attributes("storage")
          .get("strictContentTypeValidation"),
      is(false));

  repositoryManager.delete(HOSTED_NAME);
}
 

private UploadHandler getUploadHandler(final Repository repository)
{
  if (!(repository.getType() instanceof HostedType)) {
    throw new ValidationErrorsException(
        format("Uploading components to a '%s' type repository is unsupported, must be '%s'",
            repository.getType().getValue(), HostedType.NAME));
  }

  String repositoryFormat = repository.getFormat().toString();
  UploadHandler uploadHandler = uploadHandlers.get(repositoryFormat);

  if (uploadHandler == null) {
    throw new ValidationErrorsException(
        format("Uploading components to '%s' repositories is unsupported", repositoryFormat));
  }

  return uploadHandler;
}
 

@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(handlerA.getDefinition()).thenReturn(uploadA);
  when(handlerB.getDefinition()).thenReturn(uploadB);
  when(handlerA.getValidatingComponentUpload(componentUploadCaptor.capture())).thenReturn(validatingComponentUpload);
  when(handlerB.getValidatingComponentUpload(componentUploadCaptor.capture())).thenReturn(validatingComponentUpload);
  when(validatingComponentUpload.getComponentUpload()).thenAnswer(i -> componentUploadCaptor.getValue());

  when(repository.getFormat()).thenReturn(new Format("a")
  {
  });
  when(repository.getType()).thenReturn(new HostedType());
  when(repository.getConfiguration()).thenReturn(configuration);
  when(configuration.isOnline()).thenReturn(true);

  Map<String, UploadHandler> handlers = new HashMap<>();
  handlers.put("a", handlerA);
  handlers.put("b", handlerB);

  underTest = new UploadManagerImpl(handlers, blobStoreAwareMultipartHelper);
}
 

@Test
public void testAdapt_hostedRepository() throws Exception {
  Repository repository = createRepository(new HostedType());

  SimpleApiHostedRepository hostedRepository = (SimpleApiHostedRepository) underTest.adapt(repository);
  assertRepository(hostedRepository, "hosted", true);
  assertThat(hostedRepository.getStorage().getStrictContentTypeValidation(), is(true));
  assertThat(hostedRepository.getStorage().getWritePolicy(), is("ALLOW"));

  // set some values
  setStorageAttributes(repository, "default", /* non-default */ false, "DENY");
  hostedRepository = (SimpleApiHostedRepository) underTest.adapt(repository);

  assertThat(hostedRepository.getStorage().getBlobStoreName(), is("default"));
  assertThat(hostedRepository.getStorage().getStrictContentTypeValidation(), is(false));
  assertThat(hostedRepository.getStorage().getWritePolicy(), is("DENY"));
}
 

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

  switch (repository.getType().toString()) {
    case HostedType.NAME:
      return new MavenHostedApiRepository(name, url, online, getHostedStorageAttributes(repository),
          getCleanupPolicyAttributes(repository), createMavenAttributes(repository));
    case ProxyType.NAME:
      return new MavenProxyApiRepository(name, url, online, getHostedStorageAttributes(repository),
          getCleanupPolicyAttributes(repository), getProxyAttributes(repository),
          getNegativeCacheAttributes(repository), getHttpClientAttributes(repository), getRoutingRuleName(repository),
          createMavenAttributes(repository));
    default:
      return super.adapt(repository);
  }
}
 

@Test
public void updateHosted() throws Exception {
  repos.createHelmHosted(HOSTED_NAME);

  AbstractRepositoryApiRequest request = createHostedRequest(false);

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

  Repository repository = repositoryManager.get(request.getName());
  assertNotNull(repository);

  assertThat(repository.getConfiguration().attributes("storage")
          .get("strictContentTypeValidation"),
      is(false));

  repositoryManager.delete(HOSTED_NAME);
}
 

@Before
public void setUp() throws Exception {
  type = new HostedType();
  format = new Format("value") { };

  repository = mock(Repository.class);
  when(repository.getFormat()).thenReturn(format);
  when(repository.getType()).thenReturn(type);
}
 

@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");
}
 

@Test
public void testAdapt_hostedRepository() throws Exception {
  Repository repository = createRepository(new HostedType(), LayoutPolicy.STRICT, VersionPolicy.MIXED);

  MavenHostedApiRepository hostedRepository = (MavenHostedApiRepository) underTest.adapt(repository);
  assertRepository(hostedRepository, "hosted", true);
  assertThat(hostedRepository.getMaven().getLayoutPolicy(), is("STRICT"));
  assertThat(hostedRepository.getMaven().getVersionPolicy(), is("MIXED"));
  // Check fields are populated, actual values validated with SimpleApiRepositoryAdapterTest
  assertThat(hostedRepository.getCleanup(), nullValue());
  assertThat(hostedRepository.getStorage(), notNullValue());
}
 

@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 RebuildMaven2MetadataTask(@Named(HostedType.NAME) final Type hostedType,
                                 @Named(Maven2Format.NAME) final Format maven2Format)
{
  this.hostedType = checkNotNull(hostedType);
  this.maven2Format = checkNotNull(maven2Format);
}
 

@Inject
public AptHostedRecipe(final HighAvailabilitySupportChecker highAvailabilitySupportChecker,
                       @Named(HostedType.NAME) final Type type,
                       @Named(AptFormat.NAME) final Format format)
{
  super(highAvailabilitySupportChecker, type, format);
}
 

@Test
public void testAdapt_hostedRepository() throws Exception {
  Repository repository = createRepository(new HostedType(), "bionic", "asdf", null, null);

  AptHostedApiRepository hostedRepository = (AptHostedApiRepository) underTest.adapt(repository);
  assertRepository(hostedRepository, "hosted", true);
  assertThat(hostedRepository.getApt().getDistribution(), is("bionic"));
  assertThat(hostedRepository.getAptSigning(), nullValue());

  // only include public key if it is encrypted
  repository.getConfiguration().attributes("apt").set("passphrase", "mypass");
  hostedRepository = (AptHostedApiRepository) underTest.adapt(repository);
  assertThat(hostedRepository.getAptSigning().getKeypair(), is("asdf"));
  assertThat(hostedRepository.getAptSigning().getPassphrase(), nullValue());
}
 

@Test
public void createHosted_noAuthc() throws Exception {
  setBadCredentials();
  AbstractRepositoryApiRequest request = createHostedRequest(true);
  Response response = post(getCreateRepositoryPathUrl(HostedType.NAME), request);
  assertEquals(Status.UNAUTHORIZED.getStatusCode(), response.getStatus());
}
 

@Before
public void setUp() throws Exception {
  Config config = new Config();
  config.blobStoreName = BLOB_STORE_NAME;
  when(blobStore.getBlobStoreConfiguration()).thenReturn(blobStoreConfiguration);
  when(blobStoreConfiguration.getName()).thenReturn(BLOB_STORE_NAME);
  when(blobStoreConfiguration.getType()).thenReturn(FileBlobStore.TYPE);
  when(repository.facet(ConfigurationFacet.class)).thenReturn(configurationFacet);
  when(repository.getType()).thenReturn(new HostedType());
  when(configurationFacet
      .readSection(any(Configuration.class), eq(STORAGE), eq(StorageFacetImpl.Config.class)))
      .thenReturn(config);
  when(nodeAccess.getId()).thenReturn(NODE_ID);
  when(blob.getId()).thenReturn(blobId);
  when(blob.getMetrics()).thenReturn(blobMetrics);
  when(blobId.asUniqueString()).thenReturn(BLOB_ID);
  underTest = new StorageFacetImpl(
      nodeAccess,
      blobStoreManager,
      () -> databaseInstance,
      bucketEntityAdapter,
      componentEntityAdapter,
      assetEntityAdapter,
      clientInfoProvider,
      contentValidatorSelector,
      mimeRulesSourceSelector,
      storageFacetManager,
      componentFactory,
      violationFactory
  );
  underTest.attach(repository);
}
 

@JsonCreator
public HostedRepositoryApiRequest(
    @JsonProperty("name") final String name,
    @JsonProperty("format") final String format,
    @JsonProperty("online") final Boolean online,
    @JsonProperty("storage") final HostedStorageAttributes storage,
    @JsonProperty("cleanup") final CleanupPolicyAttributes cleanup)
{
  super(name, format, HostedType.NAME, online);
  this.storage = storage;
  this.cleanup = cleanup;
}
 

@JsonCreator
public SimpleApiHostedRepository(
    @JsonProperty("name") final String name,
    @JsonProperty("format") final String format,
    @JsonProperty("url") final String url,
    @JsonProperty("online") final Boolean online,
    @JsonProperty("storage") final HostedStorageAttributes storage,
    @JsonProperty("cleanup") final CleanupPolicyAttributes cleanup)
{
  super(name, format, HostedType.NAME, url, online);
  this.storage = storage;
  this.cleanup = cleanup;
}
 

@Test
public void rebuildIndexShouldThrowExceptionIfInsufficientPermissions() throws Exception {
  when(repository.getType()).thenReturn(new HostedType());
  doThrow(new AuthorizationException("User is not permitted."))
      .when(repositoryPermissionChecker)
      .ensureUserCanAdmin(any(), any());
  expectedException.expect(AuthorizationException.class);

  authorizingRepositoryManager.rebuildSearchIndex("repository");

  verify(repositoryManager).get(eq("repository"));
  verify(repositoryPermissionChecker).ensureUserCanAdmin(eq(EDIT), eq(repository));
  verifyNoMoreInteractions(repositoryManager, repositoryPermissionChecker, taskScheduler);
}
 

@Test
public void rebuildIndexShouldTriggerTask() throws Exception {
  TaskConfiguration taskConfiguration = mock(TaskConfiguration.class);
  when(taskScheduler.createTaskConfigurationInstance(any())).thenReturn(taskConfiguration);
  when(repository.getType()).thenReturn(new HostedType());

  authorizingRepositoryManager.rebuildSearchIndex("repository");

  verify(repositoryManager).get(eq("repository"));
  verify(repositoryPermissionChecker).ensureUserCanAdmin(eq(EDIT), eq(repository));
  verify(taskScheduler).createTaskConfigurationInstance(RebuildIndexTaskDescriptor.TYPE_ID);
  verify(taskScheduler).submit(any());
  verifyNoMoreInteractions(repositoryManager, repositoryPermissionChecker, taskScheduler);
}
 

@Test
public void invalidateCacheShouldThrowExceptionIfRepositoryTypeIsNotProxyOrGroup() throws Exception {
  when(repository.getType()).thenReturn(new HostedType());
  expectedException.expect(IncompatibleRepositoryException.class);

  authorizingRepositoryManager.invalidateCache("repository");

  verify(repositoryManager).get(eq("repository"));
  verifyNoMoreInteractions(repositoryManager, repositoryPermissionChecker, taskScheduler);
}
 

@Test
public void hostedEnabledNexusConanHostedEnabledIsTrueHaSupportIsTrue() {
  System.setProperty(HOSTED_ENABLED_PROPERTY, "true");
  when(highAvailabilitySupportChecker.isSupported(ConanFormat.NAME)).thenReturn(true);
  ConanHostedRecipe conanHostedRecipe = new ConanHostedRecipe(new HostedType(), new ConanFormat(), null);
  conanHostedRecipe.setHighAvailabilitySupportChecker(highAvailabilitySupportChecker);
  assertThat(conanHostedRecipe.isFeatureEnabled(), is(true));
}
 

@Before
public void setUp() {
  when(helmFormat.getValue()).thenReturn(HelmFormat.NAME);
  helmProxyRecipe = new HelmProxyRecipe(new ProxyType(), helmFormat);
  helmHostedRecipe = new HelmHostedRecipe(new HostedType(), helmFormat);
  helmProxyRecipe.setHighAvailabilitySupportChecker(highAvailabilitySupportChecker);
  helmHostedRecipe.setHighAvailabilitySupportChecker(highAvailabilitySupportChecker);
}
 

@Test
public void updateHosted_noAuthz() throws Exception {
  repos.createHelmHosted(HOSTED_NAME);

  setUnauthorizedUser();
  AbstractRepositoryApiRequest request = createHostedRequest(false);

  Response response = put(getUpdateRepositoryPathUrl(HostedType.NAME, HOSTED_NAME), request);
  assertEquals(Status.FORBIDDEN.getStatusCode(), response.getStatus());
}
 

@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);
}