io.restassured.builder.RequestSpecBuilder Java Examples

private static RequestSpecification getBaseRequestSpecification(User user) {
    RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
    RequestSpecBuilder requestSpecBuilder = new RequestSpecBuilder()
        .log(LogDetail.ALL)
        .setRelaxedHTTPSValidation()
        .setContentType("application/xml");

    //Only set authentication when auth is enabled
    if (BooleanUtils.toBoolean(TestProperties.get(StackInputParameterKeyEnum.ENABLE_SSL_AUTH))) {
        LOGGER.info("Setting Basic Auth for user: " + user.getUsername());
        PreemptiveBasicAuthScheme authenticationScheme = new PreemptiveBasicAuthScheme();
        authenticationScheme.setUserName(user.getUsername());
        authenticationScheme.setPassword(user.getPassword());
        requestSpecBuilder.setAuth(authenticationScheme)
            .setAuth(authenticationScheme);
    }
    return requestSpecBuilder.build().redirects().follow(true);
}
 

@BeforeEach
void setup(GuiceJamesServer server) throws Exception {
    server.getProbe(DataProbeImpl.class)
        .fluent()
        .addDomain(DOMAIN)
        .addUser(USERNAME, PASSWORD);

    RestAssured.requestSpecification = new RequestSpecBuilder()
            .setContentType(ContentType.JSON)
            .setAccept(ContentType.JSON)
            .setConfig(newConfig().encoderConfig(encoderConfig().defaultContentCharset(StandardCharsets.UTF_8)))
            .setPort(server.getProbe(JmapGuiceProbe.class).getJmapPort().getValue())
            .build();
    accessToken = authenticateJamesUser(baseUri(server), Username.of(USERNAME), PASSWORD);

    timer = new Timer();
}
 

@Test
public void downloadingAMailShouldFailWhenUnknown() throws Exception {
    mailRepositoryStore.create(URL_MY_REPO);

    RestAssured.requestSpecification = new RequestSpecBuilder().setPort(webAdminServer.getPort().getValue())
        .setBasePath(MailRepositoriesRoutes.MAIL_REPOSITORIES)
        .build();
    RestAssured.registerParser(Constants.RFC822_CONTENT_TYPE, Parser.TEXT);

    String name = "name";
    given()
        .accept(Constants.RFC822_CONTENT_TYPE)
    .when()
        .get(PATH_ESCAPED_MY_REPO + "/mails/" + name)
    .then()
        .statusCode(HttpStatus.NOT_FOUND_404)
        .body("statusCode", is(404))
        .body("type", is(ErrorResponder.ErrorType.NOT_FOUND.getType()))
        .body("message", is("Could not retrieve " + name));
}
 

private RequestSpecification defaultRequestSpecification()
{
    RequestSpecBuilder requestSpecification = new RequestSpecBuilder();

    requestSpecification.addFilter( new CookieFilter() );
    requestSpecification.addFilter( new SessionFilter() );
    requestSpecification.addFilter( new AuthFilter() );
    requestSpecification.setContentType( ContentType.JSON );

    return requestSpecification.build();
}
 

private RequestSpecBuilder createReqSpec() {
    RequestSpecBuilder reqSpec = reqSpecSupplier.get();
    if(reqSpecCustomizer != null) {
        reqSpecCustomizer.accept(reqSpec);
    }
    return reqSpec;
}
 

private RequestSpecBuilder createReqSpec() {
    RequestSpecBuilder reqSpec = reqSpecSupplier.get();
    if(reqSpecCustomizer != null) {
        reqSpecCustomizer.accept(reqSpec);
    }
    return reqSpec;
}
 

@BeforeEach
default void setup(GuiceJamesServer server) throws Exception {

    RestAssured.requestSpecification = new RequestSpecBuilder()
        .setContentType(ContentType.JSON)
        .setAccept(ContentType.JSON)
        .setConfig(newConfig().encoderConfig(encoderConfig().defaultContentCharset(StandardCharsets.UTF_8)))
        .setPort(server.getProbe(JmapGuiceProbe.class).getJmapPort().getValue())
        .build();
}
 

@Before
public void createApi() {
    api = ApiClient.api(ApiClient.Config.apiConfig().reqSpecSupplier(
            () -> new RequestSpecBuilder()
                    .setConfig(config().objectMapperConfig(objectMapperConfig().defaultObjectMapper(gson())))
                    .addFilter(new ErrorLoggingFilter())
                    .setBaseUri("http://petstore.swagger.io:80/v2"))).user();
}
 

@Test
public void testRouteRegistrationMTLS() {
    RequestSpecification spec = new RequestSpecBuilder()
            .setBaseUri(String.format("%s://%s", url.getProtocol(), url.getHost()))
            .setPort(url.getPort())
            .setKeyStore("client-keystore.jks", "password")
            .setTrustStore("client-truststore.jks", "password")
            .build();
    given().spec(spec).get("/my-path").then().body(containsString("OK"));
}
 

@BeforeAll
static void prepareSpec() {
  requestSpecification = new RequestSpecBuilder()
    .addFilters(asList(new ResponseLoggingFilter(), new RequestLoggingFilter()))
    .setBaseUri("http://localhost:3000/")
    .build();
}
 

static RequestSpecification spec(int port) {
    return new RequestSpecBuilder()
            .setBaseUri("http://localhost")
            .setPort(port)
            .setConfig(RestAssuredConfig.config()
                    .objectMapperConfig(new ObjectMapperConfig(new Jackson2Mapper((aClass, s) -> mapper))))
            .build();
}
 

@BeforeEach
void setUp() {
    VersionParser versionParser = new VersionParser(SUPPORTED_VERSIONS);
    server = new JMAPServer(TEST_CONFIGURATION, FAKE_ROUTES_HANDLERS, versionParser);
    server.start();

    RestAssured.requestSpecification = new RequestSpecBuilder()
        .setContentType(ContentType.JSON)
        .setAccept(ContentType.JSON)
        .setConfig(newConfig().encoderConfig(encoderConfig().defaultContentCharset(StandardCharsets.UTF_8)))
        .setPort(server.getPort().getValue())
        .build();
}
 

@Before
public void createApi() {
    api = ApiClient.api(ApiClient.Config.apiConfig().reqSpecSupplier(
            () -> new RequestSpecBuilder()
                    .setConfig(config().objectMapperConfig(objectMapperConfig().defaultObjectMapper(jackson())))
                    .addFilter(new ErrorLoggingFilter())
                    .setBaseUri("http://petstore.swagger.io:80/v2"))).user();
}
 

private RequestSpecBuilder createReqSpec() {
    RequestSpecBuilder reqSpec = reqSpecSupplier.get();
    if(reqSpecCustomizer != null) {
        reqSpecCustomizer.accept(reqSpec);
    }
    return reqSpec;
}
 

@BeforeEach
void setup(GuiceJamesServer server) throws Throwable {
    WebAdminGuiceProbe webAdminProbe = server.getProbe(WebAdminGuiceProbe.class);
    mailboxProbe = server.getProbe(MailboxProbeImpl.class);
    aclProbe = server.getProbe(ACLProbeImpl.class);

    Port jmapPort = server.getProbe(JmapGuiceProbe.class).getJmapPort();
    RestAssured.requestSpecification = new RequestSpecBuilder()
        .setContentType(ContentType.JSON)
        .setAccept(ContentType.JSON)
        .setConfig(newConfig().encoderConfig(encoderConfig().defaultContentCharset(StandardCharsets.UTF_8)))
        .setPort(jmapPort.getValue())
        .build();
    RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
    webadminSpecification = WebAdminUtils.buildRequestSpecification(webAdminProbe.getWebAdminPort())
        .build();

    server.getProbe(DataProbeImpl.class).fluent()
        .addDomain(DOMAIN)
        .addUser(ALICE, ALICE_SECRET)
        .addUser(BOB, BOB_SECRET);
    accessToken = authenticateJamesUser(baseUri(jmapPort), Username.of(ALICE), ALICE_SECRET);

    CassandraProbe probe = server.getProbe(CassandraProbe.class);
    ClusterConfiguration cassandraConfiguration = probe.getConfiguration();
    try (Cluster cluster = ClusterFactory.create(cassandraConfiguration)) {
        try (Session session = cluster.connect(probe.getMainKeyspaceConfiguration().getKeyspace())) {
            simulateGhostMailboxBug(session);
        }
    }
}
 

@Before
public void createApi() {
    api = ApiClient.api(ApiClient.Config.apiConfig().reqSpecSupplier(
            () -> new RequestSpecBuilder()
                    .setConfig(config().objectMapperConfig(objectMapperConfig().defaultObjectMapper(gson())))
                    .addFilter(new ErrorLoggingFilter())
                    .setBaseUri("http://petstore.swagger.io:80/v2"))).store();
}
 

@BeforeEach
void setUp() {
    mailRepository = new ReceivedMailRepository();

    server = HTTPConfigurationServer.onRandomPort(new SMTPBehaviorRepository(), mailRepository)
        .start();

    RestAssured.requestSpecification = new RequestSpecBuilder()
        .setContentType(ContentType.JSON)
        .setAccept(ContentType.JSON)
        .setConfig(newConfig().encoderConfig(encoderConfig().defaultContentCharset(StandardCharsets.UTF_8)))
        .setPort(server.getPort().getValue())
        .setBasePath("/smtpMails")
        .build();
}
 

@Before
public void createApi() {
    api = ApiClient.api(ApiClient.Config.apiConfig().reqSpecSupplier(
            () -> new RequestSpecBuilder()
                    .setConfig(config().objectMapperConfig(objectMapperConfig().defaultObjectMapper(jackson())))
                    .addFilter(new ErrorLoggingFilter())
                    .setBaseUri("http://petstore.swagger.io:80/v2"))).fake();
}
 

@BeforeEach
void setup() {
    RestAssured.requestSpecification = new RequestSpecBuilder()
        .setContentType(ContentType.JSON)
        .setAccept(ContentType.JSON)
        .setConfig(newConfig().encoderConfig(encoderConfig().defaultContentCharset(StandardCharsets.UTF_8)))
        .setBaseUri("http://" + linshareExtension.getLinshare().getIp())
        .setPort(linshareExtension.getLinshare().getPort())
        .build();
    RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();
}
 

public CreateXmlItemOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setContentType("application/xml");
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

private UserApi(Supplier<RequestSpecBuilder> reqSpecSupplier) {
    this.reqSpecSupplier = reqSpecSupplier;
}
 

public DeletePetOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

public CreateUsersWithListInputOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setContentType("*/*");
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

public FindPetsByTagsOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

public FindPetsByStatusOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

public DeletePetOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

public UpdateUserOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setContentType("*/*");
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

public TestClassnameOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setContentType("application/json");
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}
 

private FakeClassnameTags123Api(Supplier<RequestSpecBuilder> reqSpecSupplier) {
    this.reqSpecSupplier = reqSpecSupplier;
}
 

public UploadFileWithRequiredFileOper(RequestSpecBuilder reqSpec) {
    this.reqSpec = reqSpec;
    reqSpec.setContentType("multipart/form-data");
    reqSpec.setAccept("application/json");
    this.respSpec = new ResponseSpecBuilder();
}