Java JerseyTest类代码示例

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
private JerseyTest createJerseyTest(Boolean binaryCompressionOnly) {
	return new JerseyTest() {
		@Override
		protected Application configure() {
			ResourceConfig config = new ResourceConfig();
			config.register(TestResource.class);
			config.register(EncodingFilter.class);
			config.register(GZipEncoder.class);
			config.register(GatewayBinaryResponseFilter.class);
			if (binaryCompressionOnly != null) {
				config.property(GatewayBinaryResponseFilter.BINARY_COMPRESSION_ONLY_PROPERTY,
						binaryCompressionOnly);
			}
			return config;
		}
	};
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
@Override
protected Application configure() {
    ResourceConfig resourceConfig = new ResourceConfig()
            .register(LocatorFeature.class)
            .register(JacksonFeature.class)
            .register(RxJerseyClientFeature.class)
            .register(ServerResource.class)
            .register(new AbstractBinder() {
                @Override
                protected void configure() {
                    bind(RxJerseyTest.this).to(JerseyTest.class);
                }
            });

    configure(resourceConfig);

    return resourceConfig;
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
public void setup() throws Exception {
  singletons.add(new InternalExceptionMapper());

  test = new JerseyTest() {
    @Override
    protected TestContainerFactory getTestContainerFactory() throws TestContainerException {
      return new InMemoryTestContainerFactory();
    }

    @Override
    protected DeploymentContext configureDeployment() {
      final DropwizardResourceConfig resourceConfig = new DropwizardResourceConfig();

      for (Object singleton : singletons) {
        resourceConfig.register(singleton);
      }

      ServletDeploymentContext deploymentContext = ServletDeploymentContext.builder(resourceConfig)
          .initParam(ServletProperties.JAXRS_APPLICATION_CLASS, DropwizardResourceConfig.class.getName())
          .build();

      return deploymentContext;

    }

    @Override
    protected void configureClient(ClientConfig config) {
      JacksonJsonProvider jsonProvider = new JacksonJsonProvider();
      jsonProvider.setMapper(Jackson.newObjectMapper());
      config.register(jsonProvider);
    }
  };

  test.setUp();
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
@Autowired
public void setApplicationContext(final ApplicationContext context)
{
    _jerseyTest = new JerseyTest()
    {
        @Override
        protected Application configure()
        {
            // Find first available port.
            forceSet(TestProperties.CONTAINER_PORT, "0");

            ResourceConfig application = new GraviteeApplication(authenticationProviderManager);

            application.property("contextConfig", context);
            decorate(application);

            return application;
        }

        @Override
        protected void configureClient(ClientConfig config) {
            super.configureClient(config);

            config.register(ObjectMapperResolver.class);
        }
    };
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
public static synchronized Credentials signUpUser(JerseyTest test) throws Exception{
    PublicKey publicKey = getPublicKey(test);
    Credentials signInUser = TestUtils.getTestUser();
    signInUser.encryptPassword(publicKey);
    String user = test.target("/auth").request().post(TestUtils.toEntity(signInUser), String.class);
    Credentials returnedUser = TestUtils.getGson().fromJson(user,Credentials.class);

    assertEquals(signInUser.getUsername(), returnedUser.getUsername());
    return returnedUser;
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
private Response registerToken(Credentials user, PublicKey key, JerseyTest test){
    EncryptedEntity.Writter entity = new EncryptedEntity.Writter(key);
    entity.put("token", "whatwhat");

    Response response = target("/push")
            .request()
            .header(ContainerRequest.AUTHORIZATION, "CUSTOM " + user.getAuthToken())
            .buildPost(TestUtils.toEntity(entity)).invoke();
    int statusCode = response.getStatus();
    assertEquals(200,statusCode);
    return response;
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
protected JerseyTest getJerseyTest() {
  // This is instantiated on demand since we need subclasses to register the resources they need
  // passed along, but JerseyTest calls configure() from its constructor.
  if (test == null) {
    test = new JettyJerseyTest();
  }
  return test;
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
public JerseyTest getHarness() {
    return harness;
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
public static synchronized PublicKey getPublicKey(JerseyTest test) throws Exception{
        String publicKeyBytes = test.target("/auth/key").request().get(String.class);
        byte[] bytes = TestUtils.getGson().fromJson(publicKeyBytes,byte[].class);
    return Crypto.pubKeyFromBytes(bytes);
}
 

import org.glassfish.jersey.test.JerseyTest; //导入依赖的package包/类
/**
 * <ol>
 * <li>calls {@link JerseyTest#setUp()}
 * <li>passes the initialized JerseyTest to the consumer.
 * <li>calls {@link JerseyTest#tearDown()}
 * </ol>
 *
 * @param jerseyTest
 * @param test
 * @throws Exception
 */
public void runJerseyTest(JerseyTest jerseyTest, ThrowingConsumer<JerseyTest> test) throws Exception {
	try {
		jerseyTest.setUp();
		test.accept(jerseyTest);
	} finally {
		jerseyTest.tearDown();
	}
}