io.restassured.module.webtestclient.internal.WebTestClientRequestSpecificationImpl Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package io.restassured.module.webtestclient.internal;

import io.restassured.config.LogConfig;
import io.restassured.config.MultiPartConfig;
import io.restassured.config.ParamConfig;
import io.restassured.config.ParamConfig.UpdateStrategy;
import io.restassured.config.RestAssuredConfig;
import io.restassured.filter.log.RequestLoggingFilter;
import io.restassured.http.*;
import io.restassured.internal.MapCreator;
import io.restassured.internal.MapCreator.CollisionStrategy;
import io.restassured.internal.log.LogRepository;
import io.restassured.internal.mapping.ObjectMapping;
import io.restassured.internal.multipart.MultiPartInternal;
import io.restassured.internal.support.ParameterUpdater;
import io.restassured.mapper.ObjectMapper;
import io.restassured.mapper.ObjectMapperType;
import io.restassured.module.spring.commons.BodyHelper;
import io.restassured.module.spring.commons.CookieHelper;
import io.restassured.module.spring.commons.HeaderHelper;
import io.restassured.module.spring.commons.Serializer;
import io.restassured.module.spring.commons.config.AsyncConfig;
import io.restassured.module.spring.commons.config.ConfigConverter;
import io.restassured.module.spring.commons.config.ConfigMergeUtils;
import io.restassured.module.spring.commons.config.SpecificationConfig;
import io.restassured.module.webtestclient.config.RestAssuredWebTestClientConfig;
import io.restassured.module.webtestclient.config.WebTestClientParamConfig;
import io.restassured.module.webtestclient.response.WebTestClientResponse;
import io.restassured.module.webtestclient.specification.WebTestClientRequestLogSpecification;
import io.restassured.module.webtestclient.specification.WebTestClientRequestSender;
import io.restassured.module.webtestclient.specification.WebTestClientRequestSpecification;
import io.restassured.specification.ResponseSpecification;
import org.springframework.context.ApplicationContext;
import org.springframework.http.MediaType;
import org.springframework.test.web.reactive.server.EntityExchangeResult;
import org.springframework.test.web.reactive.server.WebTestClient;
import org.springframework.test.web.reactive.server.WebTestClientConfigurer;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.util.UriBuilder;

import java.io.File;
import java.io.InputStream;
import java.net.URI;
import java.net.URL;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;

import static io.restassured.internal.MapCreator.CollisionStrategy.OVERWRITE;
import static io.restassured.internal.common.assertion.AssertParameter.notNull;
import static io.restassured.internal.multipart.MultiPartInternal.OCTET_STREAM;
import static org.apache.commons.lang3.StringUtils.isNotEmpty;

public class WebTestClientRequestSpecificationImpl implements WebTestClientRequestSpecification {

    private static final String CONTENT_TYPE = "Content-Type";
    private static final String ACCEPT = "Accept";
    private final Map params = new LinkedHashMap<>();
    private final Map namedPathParams = new LinkedHashMap<>();
    private final Map queryParams = new LinkedHashMap<>();
    private final Map formParams = new LinkedHashMap<>();
    private final Map attributes = new LinkedHashMap<>();
    private final ResponseSpecification responseSpecification;
    private RestAssuredWebTestClientConfig config;
    private Object requestBody = null;
    private LogRepository logRepository;
    private WebTestClientFactory webTestClientFactory;
    private final ParameterUpdater
            parameterUpdater = new ParameterUpdater(WebTestClientRequestSpecificationImpl.this::serializeIfNeeded);
    private Headers requestHeaders = new Headers();
    private String basePath;
    private RequestLoggingFilter requestLoggingFilter;
    private List multiParts = new ArrayList<>();
    private Cookies cookies = new Cookies();
    private AsyncConfig asyncConfig;


    public WebTestClientRequestSpecificationImpl(WebTestClientFactory webTestClientFactory,
                                                 RestAssuredWebTestClientConfig config,
                                                 String basePath,
                                                 WebTestClientRequestSpecification requestSpecification,
                                                 ResponseSpecification responseSpecification) {
        this.logRepository = new LogRepository();
        this.basePath = basePath;
        this.responseSpecification = responseSpecification;
        assignConfig(config);
        this.webTestClientFactory = webTestClientFactory == null ? new BuilderBasedWebTestClientFactory(null)
                : webTestClientFactory;
        if (requestSpecification != null) {
            spec(requestSpecification);
        }
    }

    private void assignConfig(RestAssuredWebTestClientConfig config) {
        if (config == null) {
            this.config = new RestAssuredWebTestClientConfig();
        } else {
            this.config = config;
        }
    }

    @Override
    public WebTestClientRequestSpecification contentType(ContentType contentType) {
        notNull(contentType, "contentType");
        return header(CONTENT_TYPE, contentType.toString());
    }

    @Override
    public WebTestClientRequestSpecification contentType(MediaType mediaType) {
        notNull(mediaType, "mediaType");
        return header(CONTENT_TYPE, mediaType.toString());
    }

    @Override
    public WebTestClientRequestSpecification contentType(String contentType) {
        notNull(contentType, "contentType");
        return header(CONTENT_TYPE, contentType);
    }

    @Override
    public WebTestClientRequestSpecification accept(ContentType contentType) {
        notNull(contentType, "contentType");
        return header(ACCEPT, contentType.getAcceptHeader());
    }

    @Override
    public WebTestClientRequestSpecification accept(MediaType... mediaTypes) {
        notNull(mediaTypes, "mediaTypes");
        return header(ACCEPT, MediaType.toString(Arrays.asList(mediaTypes)));
    }

    @Override
    public WebTestClientRequestSpecification accept(String mediaTypes) {
        notNull(mediaTypes, "mediaTypes");
        return header(ACCEPT, mediaTypes);
    }

    @Override
    public WebTestClientRequestSpecification headers(String firstHeaderName, Object firstHeaderValue, Object... headerNameValuePairs) {
        return headers(MapCreator.createMapFromParams(CollisionStrategy.MERGE,
                firstHeaderName, firstHeaderValue, headerNameValuePairs));
    }

    @Override
    public WebTestClientRequestSpecification headers(Map headers) {
        notNull(headers, "headers");
        this.requestHeaders = HeaderHelper.headers(requestHeaders, headers, config);
        return this;
    }

    @Override
    public WebTestClientRequestSpecification headers(Headers headers) {
        notNull(headers, "Headers");
        requestHeaders = HeaderHelper.headers(requestHeaders, headers, config.getHeaderConfig());
        return this;
    }

    @Override
    public WebTestClientRequestSpecification header(String headerName, Object headerValue, Object... additionalHeaderValues) {
        notNull(headerName, "Header name");
        notNull(headerValue, "Header value");
        return headers(HeaderHelper.headers(requestHeaders, headerName, headerValue, config, additionalHeaderValues));
    }

    @Override
    public WebTestClientRequestSpecification header(Header header) {
        notNull(header, "Header");
        return headers(new Headers(Collections.singletonList(header)));
    }

    @Override
    public WebTestClientRequestLogSpecification log() {
        return new WebTestClientRequestLogSpecificationImpl(this);
    }

    @Override
    public WebTestClientRequestSpecification params(String firstParameterName, Object firstParameterValue,
                                                    Object... parameterNameValuePairs) {
        notNull(firstParameterName, "firstParameterName");
        notNull(firstParameterValue, "firstParameterValue");
        return params(MapCreator.createMapFromParams(OVERWRITE, firstParameterName,
                firstParameterValue, parameterNameValuePairs));
    }

    @Override
    public WebTestClientRequestSpecification params(Map parametersMap) {
        notNull(parametersMap, "parametersMap");
        parameterUpdater.updateParameters(convert(config.getParamConfig().requestParamsUpdateStrategy()),
                (Map) parametersMap, params);
        return this;
    }

    @Override
    public WebTestClientRequestSpecification param(String parameterName, Object... parameterValues) {
        notNull(parameterName, "parameterName");
        parameterUpdater.updateZeroToManyParameters(convert(config.getParamConfig().requestParamsUpdateStrategy()),
                params, parameterName, parameterValues);
        return this;
    }

    @Override
    public WebTestClientRequestSpecification param(String parameterName, Collection parameterValues) {
        notNull(parameterName, "parameterName");
        notNull(parameterValues, "parameterValues");
        parameterUpdater.updateCollectionParameter(convert(config.getParamConfig().requestParamsUpdateStrategy()),
                params, parameterName, (Collection