| /******************************************************************************* |
| * 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; |
| } |
| } |
| } |