/*******************************************************************************
* Copyright (c) 2010 The Eclipse Foundation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* The Eclipse Foundation - initial API and implementation
*******************************************************************************/
package org.eclipse.epp.mpc.tests.service;
import static org.junit.Assert.*;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.LinkedHashSet;
import java.util.Set;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.epp.internal.mpc.core.ServiceLocator;
import org.eclipse.epp.internal.mpc.core.service.DefaultMarketplaceService;
import org.eclipse.epp.internal.mpc.core.service.StorageConfigurer;
import org.eclipse.epp.mpc.core.service.IMarketplaceStorageService;
import org.eclipse.epp.mpc.core.service.ServiceHelper;
import org.eclipse.epp.mpc.tests.util.PropertyStub;
import org.eclipse.userstorage.IStorage;
import org.eclipse.userstorage.IStorageService;
import org.eclipse.userstorage.IStorageService.Dynamic;
import org.eclipse.userstorage.internal.StorageService;
import org.eclipse.userstorage.spi.ICredentialsProvider;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExternalResource;
import org.mockito.Matchers;
import org.mockito.Mockito;
public class MarketplaceStorageServiceRegistrationTest {
public static class TemporaryStorageServices extends ExternalResource {
private final Set<URI> temporaryStorageServiceUris = new LinkedHashSet<URI>();
public IStorageService create(String name, String uri) {
URI _uri = URI.create(uri);
Dynamic service = IStorageService.Registry.INSTANCE.addService(name, _uri);
cleanup(service.getServiceURI());
return service;
}
public IStorageService provide(String name, String uri) {
URI _uri = URI.create(uri);
IStorageService service = IStorageService.Registry.INSTANCE.getService(_uri);
if (service != null) {
return service;
}
return create(name, uri);
}
public void cleanup(URI uri) {
temporaryStorageServiceUris.add(uri);
}
public void cleanup(String uri) {
cleanup(URI.create(uri));
}
@Override
protected void after() {
RuntimeException error = null;
for (URI uri : temporaryStorageServiceUris) {
try {
IStorageService service = IStorageService.Registry.INSTANCE.getService(uri);
if (service != null) {
((IStorageService.Dynamic) service).remove();
}
} catch (RuntimeException ex) {
if (error != null) {
error.addSuppressed(ex);
} else {
error = ex;
}
}
}
if (error != null) {
throw error;
}
}
}
@Rule
public final TemporaryStorageServices storageServices = new TemporaryStorageServices();
private ServiceLocator serviceLocator;
@Before
public void setUp() {
serviceLocator = (ServiceLocator) ServiceHelper.getMarketplaceServiceLocator();
storageServices.cleanup("https://api-test.example.org/");
storageServices.cleanup("https://api-test.example.org");
}
@After
public void cleanUp() {
setCustomConfigurers((String[]) null);
}
@Test
public void testRegisterNewStorageServiceWithSlash() {
IMarketplaceStorageService registered = serviceLocator.registerStorageService(
DefaultMarketplaceService.DEFAULT_SERVICE_LOCATION, "https://api-test.example.org/", null);
assertNotNull(registered);
assertEquals("https://api-test.example.org/", registered.getServiceUri().toString());
}
@Test
public void testRegisterNewStorageServiceWithoutSlash() {
IMarketplaceStorageService registered = serviceLocator.registerStorageService(
DefaultMarketplaceService.DEFAULT_SERVICE_LOCATION, "https://api-test.example.org", null);
assertNotNull(registered);
assertEquals("https://api-test.example.org/", registered.getServiceUri().toString());
IStorageService withoutSlash = IStorageService.Registry.INSTANCE.getService(URI.create(
"https://api-test.example.org"));
assertNull(withoutSlash);
}
@Test
public void testRegisterStorageServiceWithSlashHavingExistingWithoutSlash() {
storageServices.provide("WithoutSlash", "https://api-test.example.org");
IMarketplaceStorageService registered = serviceLocator.registerStorageService(
DefaultMarketplaceService.DEFAULT_SERVICE_LOCATION, "https://api-test.example.org/", null);
assertNotNull(registered);
assertEquals("https://api-test.example.org", registered.getServiceUri().toString());
IStorageService withSlash = IStorageService.Registry.INSTANCE.getService(URI.create(
"https://api-test.example.org/"));
assertNull(withSlash);
}
@Test
public void testRegisterStorageServiceWithoutSlashHavingExistingWithSlash() {
storageServices.provide("WithSlash", "https://api-test.example.org/");
IMarketplaceStorageService registered = serviceLocator.registerStorageService(
DefaultMarketplaceService.DEFAULT_SERVICE_LOCATION, "https://api-test.example.org", null);
assertNotNull(registered);
assertEquals("https://api-test.example.org/", registered.getServiceUri().toString());
IStorageService withoutSlash = IStorageService.Registry.INSTANCE.getService(URI.create(
"https://api-test.example.org"));
assertNull(withoutSlash);
}
@Test
public void testCleanupDuplicateStorageService() throws Exception {
IStorageService withSlash = storageServices.provide("WithSlash", "https://api-test.example.org/");
IStorageService withoutSlash = storageServices.provide("WithoutSlash", "https://api-test.example.org");
((StorageService) withSlash).getSecurePreferences().remove("username");
((StorageService) withoutSlash).getSecurePreferences().put("username", "testuser", false);
IMarketplaceStorageService registered = serviceLocator.registerStorageService(
DefaultMarketplaceService.DEFAULT_SERVICE_LOCATION, "https://api-test.example.org", null);
assertNotNull(registered);
assertEquals("https://api-test.example.org/", registered.getServiceUri().toString());
assertSame(withSlash, registered.getStorage().getService());
withoutSlash = IStorageService.Registry.INSTANCE.getService(URI.create(
"https://api-test.example.org"));
assertNull(withoutSlash);
String username = ((StorageService) withSlash).getSecurePreferences().get("username", null);
assertEquals("testuser", username);
}
@Test
public void testCleanupDuplicateEclipseOrgStorageService() throws Exception {
IStorageService withSlash = storageServices.provide("WithSlash", "https://api.eclipse.org/");
assertFalse(withSlash instanceof IStorageService.Dynamic);
IStorageService withoutSlash = storageServices.provide("WithoutSlash", "https://api.eclipse.org");
assertTrue(withoutSlash instanceof IStorageService.Dynamic);
IMarketplaceStorageService registered = serviceLocator.registerStorageService(
DefaultMarketplaceService.DEFAULT_SERVICE_LOCATION, "https://api.eclipse.org/", null);
assertNotNull(registered);
assertSame(withSlash, registered.getStorage().getService());
withoutSlash = IStorageService.Registry.INSTANCE.getService(URI.create("https://api.eclipse.org"));
assertNull(withoutSlash);
}
@Test
public void testDefaultConfigurer() throws Exception {
testConfigurer((String[]) null);
}
@Test
public void testUSS10Configurer() throws Exception {
//"org.eclipse.epp.internal.mpc.core.service.USS11ExtendedOAuthStorageConfigurer$Factory"
//"org.eclipse.epp.internal.mpc.core.service.USS11OAuthStorageConfigurer$Factory"
//"org.eclipse.epp.internal.mpc.core.service.USS10StorageConfigurer$Factory"
testConfigurer("org.eclipse.epp.internal.mpc.core.service.USS10StorageConfigurer$Factory");
}
@Test
public void testUSS11Configurer() throws Exception {
testConfigurer("org.eclipse.epp.internal.mpc.core.service.USS11OAuthStorageConfigurer$Factory");
}
@Test
public void testUSS11ExtendedConfigurer() throws Exception {
testConfigurer("org.eclipse.epp.internal.mpc.core.service.USS11ExtendedOAuthStorageConfigurer$Factory");
}
protected void testConfigurer(String... factories) throws CoreException {
setCustomConfigurers(factories);
StorageConfigurer configurer = StorageConfigurer.get();//FIXME this might return the fallback configurer
assertNotNull(configurer);
IStorage storageMock = Mockito.mock(IStorage.class);
PropertyStub.mock(storageMock, ICredentialsProvider.class, storageMock.getCredentialsProvider())
.setCredentialsProvider(Matchers.any());
configurer.configure(storageMock);
configurer.setInteractive(storageMock, false);
assertNotNull(storageMock.getCredentialsProvider());
assertFalse(isInteractive(storageMock.getCredentialsProvider()));
configurer.setInteractive(storageMock, true);
assertTrue(isInteractive(storageMock.getCredentialsProvider()));
}
private static void setCustomConfigurers(String... factories) {
if (factories == null || (factories.length == 1 && factories[0] == null)) {
System.getProperties().remove(StorageConfigurer.PROP_FACTORIES);
} else if (factories.length == 0) {
System.setProperty(StorageConfigurer.PROP_FACTORIES, "");
} else {
StringBuilder b = new StringBuilder();
for (int i = 0; i < factories.length; i++) {
if (i > 0) {
b.append(" ");
}
b.append(factories[i]);
}
System.setProperty(StorageConfigurer.PROP_FACTORIES, b.toString());
}
StorageConfigurer.unset();
}
private static boolean isInteractive(ICredentialsProvider credentialsProvider) {
if (credentialsProvider == null) {
return true;
}
if (credentialsProvider.getClass() == ICredentialsProvider.CANCEL.getClass()) {
return false;
}
try {
Method method = credentialsProvider.getClass().getMethod("isInteractive");
method.setAccessible(true);
return (boolean) method.invoke(credentialsProvider);
} catch (Throwable t) {
return false;
}
}
}