Esempio n. 1
0
  private TestContainer getContainer(ApplicationHandler application, TestContainerFactory tcf) {
    if (application == null) {
      throw new IllegalArgumentException("The application cannot be null");
    }

    return tcf.create(getBaseUri(), application);
  }
Esempio n. 2
0
  private static synchronized TestContainerFactory getDefaultTestContainerFactory() {

    if (defaultTestContainerFactoryClass == null) {
      final String factoryClassName = getSystemProperty(TestProperties.CONTAINER_FACTORY);
      if (factoryClassName != null) {
        LOGGER.log(
            Level.CONFIG,
            "Loading test container factory '{0}' specified in the '{1}' system property.",
            new Object[] {factoryClassName, TestProperties.CONTAINER_FACTORY});

        defaultTestContainerFactoryClass = loadFactoryClass(factoryClassName);
      } else {
        final TestContainerFactory[] factories =
            ServiceFinder.find(TestContainerFactory.class).toArray();
        if (factories.length > 0) {
          // if there is only one factory instance, just return it
          if (factories.length == 1) {
            // cache the class for future reuse
            defaultTestContainerFactoryClass = factories[0].getClass();
            LOGGER.log(
                Level.CONFIG,
                "Using the single found TestContainerFactory service provider '{0}'",
                defaultTestContainerFactoryClass.getName());
            return factories[0];
          }

          // if default factory is present, use it.
          for (final TestContainerFactory tcf : factories) {
            if (TestProperties.DEFAULT_CONTAINER_FACTORY.equals(tcf.getClass().getName())) {
              // cache the class for future reuse
              defaultTestContainerFactoryClass = tcf.getClass();
              LOGGER.log(
                  Level.CONFIG,
                  "Found multiple TestContainerFactory service providers, using the default found '{0}'",
                  TestProperties.DEFAULT_CONTAINER_FACTORY);
              return tcf;
            }
          }

          // default factory is not in the list - log warning and return the first found factory
          // instance
          // cache the class for future reuse
          defaultTestContainerFactoryClass = factories[0].getClass();
          LOGGER.log(
              Level.WARNING,
              "Found multiple TestContainerFactory service providers, using the first found '{0}'",
              defaultTestContainerFactoryClass.getName());
          return factories[0];
        }

        LOGGER.log(
            Level.CONFIG,
            "No TestContainerFactory configured, trying to load and instantiate the default implementation '{0}'",
            TestProperties.DEFAULT_CONTAINER_FACTORY);
        defaultTestContainerFactoryClass =
            loadFactoryClass(TestProperties.DEFAULT_CONTAINER_FACTORY);
      }
    }

    try {
      return defaultTestContainerFactoryClass.newInstance();
    } catch (final Exception ex) {
      throw new TestContainerException(
          String.format(
              "Could not instantiate test container factory '%s'",
              defaultTestContainerFactoryClass.getName()),
          ex);
    }
  }
Esempio n. 3
0
  /**
   * Returns an instance of {@link TestContainerFactory} class. This instance can be set by a
   * constructor ({@link #JerseyTest(org.glassfish.jersey.test.spi.TestContainerFactory)}, as an
   * application {@link Providers Provider} or the {@link TestContainerFactory} class can be set as
   * a {@value org.glassfish.jersey.test.TestProperties#CONTAINER_FACTORY} property.
   *
   * @return an instance of {@link TestContainerFactory} class.
   * @throws TestContainerException if the initialization of {@link TestContainerFactory} instance
   *     is not successful.
   */
  protected TestContainerFactory getTestContainerFactory() throws TestContainerException {
    if (testContainerFactory == null) {
      if (testContainerFactoryClass == null) {

        final String tcfClassName = getProperty(TestProperties.CONTAINER_FACTORY);
        if ((tcfClassName == null)) {
          Set<TestContainerFactory> testContainerFactories =
              Providers.getProviders(application.getServiceLocator(), TestContainerFactory.class);

          if (testContainerFactories.size() >= 1) {
            // if default factory is present, use it.
            for (TestContainerFactory tcFactory : testContainerFactories) {

              if (tcFactory.getClass().getName().equals(TestProperties.DEFAULT_CONTAINER_FACTORY)) {
                LOGGER.log(
                    Level.CONFIG,
                    "Found multiple TestContainerFactory implementations, using default {0}",
                    tcFactory.getClass().getName());

                testContainerFactoryClass = tcFactory.getClass(); // is this necessary?
                return tcFactory;
              }
            }

            if (testContainerFactories.size() != 1) {
              LOGGER.log(
                  Level.WARNING,
                  "Found multiple TestContainerFactory implementations, using {0}",
                  testContainerFactories.iterator().next().getClass().getName());
            }

            testContainerFactoryClass = testContainerFactories.iterator().next().getClass();
            return testContainerFactories.iterator().next();
          }
        } else {
          final Class<Object> tfClass =
              AccessController.doPrivileged(ReflectionHelper.classForNamePA(tcfClassName, null));
          if (tfClass == null) {
            throw new TestContainerException(
                "The default test container factory class name, "
                    + tcfClassName
                    + ", cannot be loaded");
          }
          try {
            testContainerFactoryClass = tfClass.asSubclass(TestContainerFactory.class);
          } catch (ClassCastException ex) {
            throw new TestContainerException(
                "The default test container factory class, "
                    + tcfClassName
                    + ", is not an instance of TestContainerFactory",
                ex);
          }
        }
      }

      try {
        return testContainerFactoryClass.newInstance();
      } catch (Exception ex) {
        throw new TestContainerException(
            "The default test container factory, "
                + testContainerFactoryClass
                + ", could not be instantiated",
            ex);
      }
    }

    return testContainerFactory;
  }