@Test
  public void testAttemptsToStopAllServicesOnCloseFailure() {
    Service s1 = mock(CacheProvider.class);
    Service s2 = mock(FooProvider.class);
    Service s3 = mock(CacheLoaderWriterProvider.class);

    ServiceLocator locator = new ServiceLocator(s1, s2, s3);
    try {
      locator.startAllServices();
    } catch (Exception e) {
      fail();
    }
    final RuntimeException thrown = new RuntimeException();
    doThrow(thrown).when(s1).stop();

    try {
      locator.stopAllServices();
      fail();
    } catch (Exception e) {
      assertThat(e, CoreMatchers.<Exception>sameInstance(thrown));
    }
    verify(s1).stop();
    verify(s2).stop();
    verify(s3).stop();
  }
  private void generateMetadata(Archiver archiver)
      throws ArchiverException, MojoExecutionException {

    Log log = getLog();
    File tmpServicesDir = new File(new File(tmpDirectory, "META-INF"), "services");
    File buildServicesDir = new File(new File(buildOutputDirectory, "META-INF"), "services");
    if (!tmpServicesDir.mkdirs()) {
      throw new MojoExecutionException(
          "Error while creating the directory: " + tmpServicesDir.getPath());
    }

    log.debug("Initializing class scanner ...");
    ClassScanner scanner = new ClassScanner(buildOutputDirectory);
    for (Artifact artifact :
        filterArtifacts(
            (Set<Artifact>) project.getArtifacts(),
            new ScopeArtifactFilter(Artifact.SCOPE_COMPILE))) {
      scanner.addToClasspath(artifact.getFile());
    }
    List<ServiceLocator> serviceLocators = new ArrayList<ServiceLocator>(serviceClassNames.length);
    for (String serviceClassName : serviceClassNames) {
      // If the user provided its own service file, skip generation
      File file = new File(buildServicesDir, serviceClassName);
      if (file.exists()) {
        log.debug(file + " exists; don't scan for " + serviceClassName + " implementation");
      } else {
        ServiceLocator sl = new ServiceLocator(serviceClassName);
        serviceLocators.add(sl);
        scanner.addVisitor(sl);
      }
    }
    try {
      scanner.scan();
    } catch (ClassScannerException e) {
      throw new MojoExecutionException("Failed to scan classes for services", e);
    }
    for (ServiceLocator sl : serviceLocators) {
      File file = new File(tmpServicesDir, sl.getServiceClassName());
      if (!sl.getImplementations().isEmpty()) {
        String destFileName = "META-INF/services/" + sl.getServiceClassName();
        log.info("Generating " + destFileName);
        try {
          Writer out = new OutputStreamWriter(new FileOutputStream(file));
          try {
            for (String impl : sl.getImplementations()) {
              log.debug("  " + impl);
              out.write(impl);
              out.write("\n");
            }
          } finally {
            out.close();
          }
        } catch (IOException e) {
          throw new MojoExecutionException("Unable to create temporary file " + file, e);
        }
        archiver.addFile(file, destFileName);
      }
    }
  }
 @Override
 public IServiceLocator createServiceLocator(
     IServiceLocator parent,
     AbstractServiceFactory factory,
     IDisposable owner,
     IEclipseContext context) {
   ServiceLocator serviceLocator = new ServiceLocator(parent, factory, owner);
   serviceLocator.setContext(context);
   return serviceLocator;
 }
 public static void main(String[] args) {
   Service service = ServiceLocator.getService("Service1");
   service.execute();
   service = ServiceLocator.getService("Service2");
   service.execute();
   service = ServiceLocator.getService("Service1");
   service.execute();
   service = ServiceLocator.getService("Service2");
   service.execute();
 }
 @Override
 public IServiceLocator createServiceLocator(
     IServiceLocator parent, AbstractServiceFactory factory, IDisposable owner) {
   ServiceLocator serviceLocator = new ServiceLocator(parent, factory, owner);
   // System.err.println("parentLocator: " + parent); //$NON-NLS-1$
   if (parent != null) {
     IEclipseContext ctx = parent.getService(IEclipseContext.class);
     if (ctx != null) {
       serviceLocator.setContext(ctx.createChild());
     }
   }
   return serviceLocator;
 }
  @Test
  public void testClassHierarchies() {
    ServiceLocator provider = new ServiceLocator();
    final Service service = new ChildTestService();
    provider.addService(service);
    assertThat(provider.getService(FooProvider.class), sameInstance(service));
    final Service fancyCacheProvider = new FancyCacheProvider();
    provider.addService(fancyCacheProvider);

    final Collection<CacheProvider> servicesOfType =
        provider.getServicesOfType(CacheProvider.class);
    assertThat(servicesOfType, is(not(empty())));
    assertThat(servicesOfType.iterator().next(), sameInstance(fancyCacheProvider));
  }
  @Test
  public void testDoesNotUseTCCL() {
    Thread.currentThread()
        .setContextClassLoader(
            new ClassLoader() {
              @Override
              public Enumeration<URL> getResources(String name) throws IOException {
                throw new AssertionError();
              }
            });

    ServiceLocator serviceLocator = new ServiceLocator();
    serviceLocator.getService(TestService.class);
  }
  @Test
  public void testStopAllServicesOnlyStopsEachServiceOnce() throws Exception {
    Service s1 =
        mock(CacheProvider.class, withSettings().extraInterfaces(CacheLoaderWriterProvider.class));

    ServiceLocator locator = new ServiceLocator(s1);
    try {
      locator.startAllServices();
    } catch (Exception e) {
      fail();
    }

    locator.stopAllServices();
    verify(s1, times(1)).stop();
  }
  public void updateNotification() {
    if (!Preferences.isNotificationEnabled() || !playServicesAvailable) return;

    String title = null;
    String subtitle = null;
    long time = 0;

    if ((this.lastPublishedLocation != null) && Preferences.isNotificationLocationEnabled()) {
      time = this.lastPublishedLocationTime.getTime();

      if ((this.lastPublishedLocation.getGeocoder() != null)
          && Preferences.isNotificationGeocoderEnabled()) {
        title = this.lastPublishedLocation.toString();
      } else {
        title = this.lastPublishedLocation.toLatLonString();
      }
    } else {
      title = this.context.getString(R.string.app_name);
    }

    subtitle =
        ServiceLocator.getStateAsString(this.context)
            + " | "
            + ServiceBroker.getStateAsString(this.context);

    notificationBuilder.setContentTitle(title);
    notificationBuilder
        .setSmallIcon(R.drawable.ic_notification)
        .setContentText(subtitle)
        .setPriority(android.support.v4.app.NotificationCompat.PRIORITY_MIN);
    if (time != 0) notificationBuilder.setWhen(this.lastPublishedLocationTime.getTime());

    this.notification = notificationBuilder.build();
    this.context.startForeground(Defaults.NOTIFCATION_ID, this.notification);
  }
  @Test
  public void testAttemptsToStopStartedServicesOnInitFailure() {
    Service s1 = new ParentTestService();
    FancyCacheProvider s2 = new FancyCacheProvider();

    ServiceLocator locator = new ServiceLocator(s1, s2);
    try {
      locator.startAllServices();
      fail();
    } catch (Exception e) {
      // see org.ehcache.spi.ParentTestService.start()
      assertThat(e, instanceOf(RuntimeException.class));
      assertThat(e.getMessage(), is("Implement me!"));
    }
    assertThat(s2.startStopCounter, is(0));
  }
 /** Uninstalls a feature and checks that feature is properly uninstalled. */
 public void unInstallAndCheckFeature(String feature) throws Exception {
   System.err.println(executeCommand("features:uninstall " + feature));
   FeaturesService featuresService = ServiceLocator.getOsgiService(FeaturesService.class);
   System.err.println(executeCommand("osgi:list -t 0"));
   Assert.assertFalse(
       "Expected " + feature + " feature to be installed.",
       featuresService.isInstalled(featuresService.getFeature(feature)));
 }
  @Test
  public void testCanOverrideServiceDependencyWithoutOrderingProblem() throws Exception {
    final AtomicBoolean started = new AtomicBoolean(false);
    ServiceLocator serviceLocator = new ServiceLocator(new TestServiceConsumerService());
    serviceLocator.addService(
        new TestService() {
          @Override
          public void start(ServiceProvider<Service> serviceProvider) {
            started.set(true);
          }

          @Override
          public void stop() {
            // no-op
          }
        });
    serviceLocator.startAllServices();
    assertThat(started.get(), is(true));
  }
Exemple #13
0
  @Test
  public void testCreateTokenWithRefreshToken() throws Exception {
    when(ServiceLocator.getInstance().getTokenStore().get(anyString()))
        .thenReturn(new AuthenticationBuilder(claim).build());
    when(ServiceLocator.getInstance().getIdmService().listRoles(anyString(), anyString()))
        .thenReturn(Arrays.asList("admin", "user"));

    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent(REFRESH_TOKEN);
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_GRANT_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(201, resp.getStatus());
    assertTrue(resp.getContent().contains("expires_in\":10"));
    assertTrue(resp.getContent().contains("Bearer"));
  }
  public static <T, I extends T> void registerRemoteService(
      @Nonnull final String description,
      @Nonnull final String rmiServer,
      final int rmiPort,
      @Nonnull final Class<T> service)
      throws RemoteException, NotBoundException {
    LOG.info("Registering remote service: " + description);

    IServiceProvider<T> serviceProvider =
        new ServiceLocator.ServiceProviderForRemote<T, I>(rmiServer, rmiPort, service);
    ServiceLocator.registerServiceProvider(service, serviceProvider);
  }
Exemple #15
0
  /* package */ @SuppressWarnings({"unchecked"})
  void register() {
    ServiceLocator locator = getServiceLocator();

    ActiveDescriptor<?> myselfReified = locator.reifyDescriptor(this);

    DynamicConfigurationService dcs = locator.getService(DynamicConfigurationService.class);
    DynamicConfiguration dc = dcs.createDynamicConfiguration();

    //        habitat.add(this);
    HK2Loader loader = this.model.classLoaderHolder;

    Set<Type> ctrs = new HashSet<Type>();
    ctrs.add(myselfReified.getImplementationClass());

    if (ConfigBean.class.isAssignableFrom(this.getClass())) {
      ctrs.add(ConfigBean.class);
    }

    DomDescriptor<Dom> domDesc =
        new DomDescriptor<Dom>(
            this, ctrs, Singleton.class, getImplementation(), new HashSet<Annotation>());
    domDesc.setLoader(loader);
    domDescriptor = dc.addActiveDescriptor(domDesc, false);

    String key = getKey();
    for (String contract : model.contracts) {
      ActiveDescriptor<Dom> alias = new AliasDescriptor<Dom>(locator, domDescriptor, contract, key);
      dc.addActiveDescriptor(alias, false);
    }
    if (key != null) {
      ActiveDescriptor<Dom> alias =
          new AliasDescriptor<Dom>(locator, domDescriptor, model.targetTypeName, key);
      dc.addActiveDescriptor(alias, false);
    }

    dc.commit();

    serviceHandle = getHabitat().getServiceHandle(domDescriptor);
  }
  /**
   * Executes a shell command and returns output as a String. Commands have a default timeout of 10
   * seconds.
   *
   * @param timeout The amount of time in millis to wait for the command to execute.
   * @param silent Specifies if the command should be displayed in the screen.
   * @param commands The command to execute.
   */
  protected String executeCommands(
      final long timeout, final boolean silent, final String... commands) {
    String response = null;
    final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    final PrintStream printStream = new PrintStream(byteArrayOutputStream);
    final CommandProcessor commandProcessor = ServiceLocator.getOsgiService(CommandProcessor.class);
    final CommandSession commandSession =
        commandProcessor.createSession(System.in, printStream, printStream);
    commandSession.put("APPLICATION", System.getProperty("karaf.name", "root"));
    commandSession.put("USER", "karaf");
    FutureTask<String> commandFuture =
        new FutureTask<String>(
            new Callable<String>() {
              public String call() throws Exception {
                for (String command : commands) {
                  boolean keepRunning = true;

                  if (!silent) {
                    System.out.println(command);
                    System.out.flush();
                  }

                  while (!Thread.currentThread().isInterrupted() && keepRunning) {
                    try {
                      commandSession.execute(command);
                      keepRunning = false;
                    } catch (Exception e) {
                      if (retryException(e)) {
                        keepRunning = true;
                        sleep(1000);
                      } else {
                        throw new CommandExecutionException(e);
                      }
                    }
                  }
                }
                printStream.flush();
                return byteArrayOutputStream.toString();
              }
            });

    try {
      executor.submit(commandFuture);
      response = commandFuture.get(timeout, TimeUnit.MILLISECONDS);
    } catch (ExecutionException e) {
      throw CommandExecutionException.launderThrowable(e.getCause());
    } catch (Exception e) {
      throw CommandExecutionException.launderThrowable(e);
    }

    return response;
  }
 public void removeExtension(IExtension extension, Object[] objects) {
   for (int i = 0; i < objects.length; i++) {
     Object object = objects[i];
     if (object instanceof ServiceFactoryHandle) {
       ServiceFactoryHandle handle = (ServiceFactoryHandle) object;
       Set locatorSet = handle.serviceLocators.keySet();
       ServiceLocator[] locators =
           (ServiceLocator[]) locatorSet.toArray(new ServiceLocator[locatorSet.size()]);
       Arrays.sort(
           locators,
           new Comparator() {
             public int compare(Object o1, Object o2) {
               ServiceLocator loc1 = (ServiceLocator) o1;
               ServiceLocator loc2 = (ServiceLocator) o2;
               int l1 =
                   ((IWorkbenchLocationService) loc1.getService(IWorkbenchLocationService.class))
                       .getServiceLevel();
               int l2 =
                   ((IWorkbenchLocationService) loc2.getService(IWorkbenchLocationService.class))
                       .getServiceLevel();
               return l1 < l2 ? -1 : (l1 > l2 ? 1 : 0);
             }
           });
       for (int j = 0; j < locators.length; j++) {
         ServiceLocator serviceLocator = locators[j];
         if (!serviceLocator.isDisposed()) {
           serviceLocator.unregisterServices(handle.serviceNames);
         }
       }
       handle.factory = null;
       for (int j = 0; j < handle.serviceNames.length; j++) {
         String serviceName = handle.serviceNames[j];
         if (factories.get(serviceName) == handle) {
           factories.remove(serviceName);
         }
       }
     }
   }
 }
Exemple #18
0
 @SuppressWarnings("unchecked")
 private static void mockServiceLocator() {
   ServiceLocator.getInstance().setClientService(mock(ClientService.class));
   ServiceLocator.getInstance().setIdmService(mock(IdMService.class));
   ServiceLocator.getInstance().setAuthenticationService(mock(AuthenticationService.class));
   ServiceLocator.getInstance().setTokenStore(mock(TokenStore.class));
   ServiceLocator.getInstance().setCredentialAuth(mock(CredentialAuth.class));
   ServiceLocator.getInstance().getTokenAuthCollection().add(mock(TokenAuth.class));
 }
  /**
   * Register the given service (consists of the interface type and the implementation) at the osgi
   * service registry and also at the service locator for singleton-style easy access.
   *
   * @param <T> type of the service interface
   * @param <I> implementation of the service
   * @param description only a descriptive string useful in the osgi console
   * @param context the bundle context, where the service is registered
   * @param service the service interface
   * @param impl the implementation
   */
  public static <T, I extends T> void registerServiceWithTracker(
      @Nonnull final String description,
      @Nonnull final BundleContext context,
      @Nonnull final Class<T> service,
      @Nonnull final I impl) {
    LOG.info("Registering OSGi service: " + description);

    final Dictionary<String, String> properties = new Hashtable<String, String>();
    properties.put("service.vendor", "DESY");
    properties.put("service.description", description);

    context.registerService(service, impl, properties);
    ServiceLocator.registerServiceTracker(
        service, ServiceLocatorFactory.createServiceTracker(context, service));
  }
  @Test
  public void testServicesInstanciatedOnceAndStartedOnce() throws Exception {

    @ServiceDependencies(TestProvidedService.class)
    class Consumer1 implements Service {
      @Override
      public void start(ServiceProvider<Service> serviceProvider) {}

      @Override
      public void stop() {}
    }

    @ServiceDependencies(TestProvidedService.class)
    class Consumer2 implements Service {
      TestProvidedService testProvidedService;

      @Override
      public void start(ServiceProvider<Service> serviceProvider) {
        testProvidedService = serviceProvider.getService(TestProvidedService.class);
      }

      @Override
      public void stop() {}
    }

    Consumer1 consumer1 = spy(new Consumer1());
    Consumer2 consumer2 = new Consumer2();
    ServiceLocator serviceLocator = new ServiceLocator();

    // add some services
    serviceLocator.addService(consumer1);
    serviceLocator.addService(consumer2);
    serviceLocator.addService(
        new TestService() {
          @Override
          public void start(ServiceProvider<Service> serviceProvider) {}

          @Override
          public void stop() {
            // no-op
          }
        });

    // simulate what is done in ehcachemanager
    serviceLocator.loadDependenciesOf(TestServiceConsumerService.class);
    serviceLocator.startAllServices();

    serviceLocator.stopAllServices();

    verify(consumer1, times(1)).start(serviceLocator);
    verify(consumer1, times(1)).stop();

    assertThat(consumer2.testProvidedService.ctors(), greaterThanOrEqualTo(1));
    assertThat(consumer2.testProvidedService.stops(), equalTo(1));
    assertThat(consumer2.testProvidedService.starts(), equalTo(1));
  }
Exemple #21
0
 /** 读取数据库中的全局参数的配置,存到缓存中 */
 private static void initSysParam() {
   try {
     String sql = "select * from T_SYS_PARAM";
     JdbcTemplate jdbc = (JdbcTemplate) ServiceLocator.getBean("jdbcTemplate");
     List list = jdbc.queryForList(sql);
     Map keyValue = new HashMap();
     for (Iterator iter = list.iterator(); iter.hasNext(); ) {
       Map m = (Map) iter.next();
       keyValue.put(m.get("CODE"), m.get("PAR_VALUE"));
     }
     setConfigMap(keyValue);
   } catch (Exception e) {
     logger.error("读取数据库中的全局参数的配置出错!");
     e.printStackTrace();
   }
 }
Exemple #22
0
  @Test
  public void testDeleteToken() throws Exception {
    when(ServiceLocator.getInstance().getTokenStore().delete("token_to_be_deleted"))
        .thenReturn(true);

    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent("token_to_be_deleted");
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_REVOKE_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(204, resp.getStatus());
  }
Exemple #23
0
  @Test
  public void testCreateTokenWithPassword() throws Exception {
    when(ServiceLocator.getInstance()
            .getCredentialAuth()
            .authenticate(any(PasswordCredentials.class)))
        .thenReturn(claim);

    HttpTester req = new HttpTester();
    req.setMethod("POST");
    req.setHeader("Content-Type", "application/x-www-form-urlencoded");
    req.setContent(DIRECT_AUTH);
    req.setURI(CONTEXT + TokenEndpoint.TOKEN_GRANT_ENDPOINT);
    req.setVersion("HTTP/1.0");

    HttpTester resp = new HttpTester();
    resp.parse(server.getResponses(req.generate()));
    assertEquals(201, resp.getStatus());
    assertTrue(resp.getContent().contains("expires_in\":10"));
    assertTrue(resp.getContent().contains("Bearer"));
  }
 /**
  * Register in service locator so that non-Spring objects can access me. This method is invoked
  * automatically by Spring.
  */
 public void init() {
   ServiceLocator.setMediaFileService(this);
 }
  @Test
  public void testCircularDeps() throws Exception {

    final class StartStopCounter {
      final AtomicInteger startCounter = new AtomicInteger(0);
      final AtomicReference<ServiceProvider<Service>> startServiceProvider =
          new AtomicReference<ServiceProvider<Service>>();
      final AtomicInteger stopCounter = new AtomicInteger(0);

      public void countStart(ServiceProvider<Service> serviceProvider) {
        startCounter.incrementAndGet();
        startServiceProvider.set(serviceProvider);
      }

      public void countStop() {
        stopCounter.incrementAndGet();
      }
    }

    @ServiceDependencies(TestProvidedService.class)
    class Consumer1 implements Service {
      final StartStopCounter startStopCounter = new StartStopCounter();

      @Override
      public void start(ServiceProvider<Service> serviceProvider) {
        assertThat(serviceProvider.getService(TestProvidedService.class), is(notNullValue()));
        startStopCounter.countStart(serviceProvider);
      }

      @Override
      public void stop() {
        startStopCounter.countStop();
      }
    }

    @ServiceDependencies(Consumer1.class)
    class Consumer2 implements Service {
      final StartStopCounter startStopCounter = new StartStopCounter();

      @Override
      public void start(ServiceProvider<Service> serviceProvider) {
        assertThat(serviceProvider.getService(Consumer1.class), is(notNullValue()));
        startStopCounter.countStart(serviceProvider);
      }

      @Override
      public void stop() {
        startStopCounter.countStop();
      }
    }

    @ServiceDependencies(Consumer2.class)
    class MyTestProvidedService extends DefaultTestProvidedService {
      final StartStopCounter startStopCounter = new StartStopCounter();

      @Override
      public void start(ServiceProvider<Service> serviceProvider) {
        assertThat(serviceProvider.getService(Consumer2.class), is(notNullValue()));
        startStopCounter.countStart(serviceProvider);
        super.start(serviceProvider);
      }

      @Override
      public void stop() {
        startStopCounter.countStop();
        super.stop();
      }
    }

    @ServiceDependencies(DependsOnMe.class)
    class DependsOnMe implements Service {
      final StartStopCounter startStopCounter = new StartStopCounter();

      @Override
      public void start(ServiceProvider<Service> serviceProvider) {
        assertThat(serviceProvider.getService(DependsOnMe.class), sameInstance(this));
        startStopCounter.countStart(serviceProvider);
      }

      @Override
      public void stop() {
        startStopCounter.countStop();
      }
    }

    ServiceLocator serviceLocator = new ServiceLocator();

    Consumer1 consumer1 = new Consumer1();
    Consumer2 consumer2 = new Consumer2();
    MyTestProvidedService myTestProvidedService = new MyTestProvidedService();
    DependsOnMe dependsOnMe = new DependsOnMe();

    // add some services
    serviceLocator.addService(consumer1);
    serviceLocator.addService(consumer2);
    serviceLocator.addService(myTestProvidedService);
    serviceLocator.addService(dependsOnMe);

    // simulate what is done in ehcachemanager
    serviceLocator.startAllServices();

    serviceLocator.stopAllServices();

    assertThat(consumer1.startStopCounter.startCounter.get(), is(1));
    assertThat(
        consumer1.startStopCounter.startServiceProvider.get(),
        CoreMatchers.<ServiceProvider<Service>>is(serviceLocator));
    assertThat(consumer2.startStopCounter.startCounter.get(), is(1));
    assertThat(
        consumer2.startStopCounter.startServiceProvider.get(),
        CoreMatchers.<ServiceProvider<Service>>is(serviceLocator));
    assertThat(myTestProvidedService.startStopCounter.startCounter.get(), is(1));
    assertThat(
        myTestProvidedService.startStopCounter.startServiceProvider.get(),
        CoreMatchers.<ServiceProvider<Service>>is(serviceLocator));
    assertThat(dependsOnMe.startStopCounter.startCounter.get(), is(1));
    assertThat(
        dependsOnMe.startStopCounter.startServiceProvider.get(),
        CoreMatchers.<ServiceProvider<Service>>is(serviceLocator));

    assertThat(consumer1.startStopCounter.stopCounter.get(), is(1));
    assertThat(consumer2.startStopCounter.stopCounter.get(), is(1));
    assertThat(myTestProvidedService.startStopCounter.stopCounter.get(), is(1));
    assertThat(dependsOnMe.startStopCounter.stopCounter.get(), is(1));
  }
  @Test
  public void testRedefineDefaultServiceWhileDependingOnIt() throws Exception {
    ServiceLocator serviceLocator = new ServiceLocator(new YetAnotherCacheProvider());

    serviceLocator.startAllServices();
  }
 @Test
 public void testCanOverrideDefaultServiceFromServiceLoader() {
   ServiceLocator locator = new ServiceLocator(new ExtendedTestService());
   TestService testService = locator.getService(TestService.class);
   assertThat(testService, instanceOf(ExtendedTestService.class));
 }
Exemple #28
0
 @Before
 public void setup() {
   mockServiceLocator();
   when(ServiceLocator.getInstance().getTokenStore().tokenExpiration())
       .thenReturn(TOKEN_TIMEOUT_SECS);
 }
Exemple #29
0
 @After
 public void teardown() {
   ServiceLocator.getInstance().getTokenAuthCollection().clear();
 }