Use baseUrl as root uri, not simple prefix, close #2758

gatling-http/src/main/scala/io/gatling/http/action/AddCookieBuilder.scala

@@ -25,7 +25,6 @@ import io.gatling.http.cookie.CookieSupport.storeCookie
 
 import akka.actor.ActorRef
 import org.asynchttpclient.cookie.Cookie
-import org.asynchttpclient.uri.Uri
 
 case class CookieDSL(name: Expression[String], value: Expression[String],
                      domain: Option[Expression[String]] = None,
@@ -52,7 +51,7 @@ class AddCookieBuilder(name: Expression[String], value: Expression[String], doma
   import AddCookieBuilder._
 
   private def defaultDomain(httpProtocol: HttpProtocol) = {
-    val baseUrlHost = httpProtocol.baseURL.map(url => Uri.create(url).getHost)
+    val baseUrlHost = httpProtocol.baseURL.map(_.getHost)
     (session: Session) => baseUrlHost match {
       case Some(host) => host.success
       case _          => NoBaseUrlFailure

gatling-http/src/main/scala/io/gatling/http/protocol/HttpProtocol.scala

@@ -34,6 +34,7 @@ import akka.actor.ActorSystem
 import com.typesafe.scalalogging.StrictLogging
 import org.asynchttpclient._
 import org.asynchttpclient.proxy._
+import org.asynchttpclient.uri.Uri
 
 object HttpProtocol extends StrictLogging {
 
@@ -95,7 +96,7 @@ object HttpProtocol extends StrictLogging {
         proxies = None,
         proxyExceptions = Nil))
 
-  def baseUrlIterator(urls: List[String]): Iterator[Option[String]] =
+  def baseUrlIterator(urls: List[Uri]): Iterator[Option[Uri]] =
     urls match {
       case Nil        => Iterator.continually(None)
       case url :: Nil => Iterator.continually(Some(url))
@@ -115,7 +116,7 @@ object HttpProtocol extends StrictLogging {
  * @param proxyPart the Proxy related configuration
  */
 case class HttpProtocol(
-  baseURLs: List[String],
+  baseURLs: List[Uri],
   warmUpUrl: Option[String],
   enginePart: HttpProtocolEnginePart,
   requestPart: HttpProtocolRequestPart,
@@ -127,7 +128,7 @@ case class HttpProtocol(
   type Components = HttpComponents
 
   private val httpBaseUrlIterator = HttpProtocol.baseUrlIterator(baseURLs)
-  def baseURL: Option[String] = httpBaseUrlIterator.next()
+  def baseURL: Option[Uri] = httpBaseUrlIterator.next()
 }
 
 case class HttpProtocolEnginePart(
@@ -160,12 +161,12 @@ case class HttpProtocolResponsePart(
   htmlResourcesInferringFilters: Option[Filters])
 
 case class HttpProtocolWsPart(
-    wsBaseURLs: List[String],
+    wsBaseURLs: List[Uri],
     reconnect: Boolean,
     maxReconnects: Option[Int]) {
 
   private val wsBaseUrlIterator = HttpProtocol.baseUrlIterator(wsBaseURLs)
-  def wsBaseURL: Option[String] = wsBaseUrlIterator.next()
+  def wsBaseURL: Option[Uri] = wsBaseUrlIterator.next()
 }
 
 case class HttpProtocolProxyPart(

gatling-http/src/main/scala/io/gatling/http/protocol/HttpProtocolBuilder.scala

@@ -29,6 +29,7 @@ import io.gatling.http.response.Response
 import io.gatling.http.util.HttpHelper
 
 import org.asynchttpclient.{ RequestBuilderBase, Realm, Request, SignatureCalculator }
+import org.asynchttpclient.uri.Uri
 
 /**
  * HttpProtocolBuilder class companion
@@ -48,9 +49,9 @@ object HttpProtocolBuilder {
  */
 case class HttpProtocolBuilder(protocol: HttpProtocol) {
 
-  def baseURL(url: String) = copy(protocol = protocol.copy(baseURLs = List(url)))
+  def baseURL(url: String) = copy(protocol = protocol.copy(baseURLs = List(Uri.create(url))))
   def baseURLs(urls: String*): HttpProtocolBuilder = baseURLs(urls.toList)
-  def baseURLs(urls: List[String]): HttpProtocolBuilder = copy(protocol = protocol.copy(baseURLs = urls))
+  def baseURLs(urls: List[String]): HttpProtocolBuilder = copy(protocol = protocol.copy(baseURLs = urls.map(Uri.create)))
   def warmUp(url: String): HttpProtocolBuilder = copy(protocol = copy(protocol.copy(warmUpUrl = Some(url))))
   def disableWarmUp: HttpProtocolBuilder = copy(protocol = protocol.copy(warmUpUrl = None))
 
@@ -118,9 +119,9 @@ case class HttpProtocolBuilder(protocol: HttpProtocol) {
 
   // wsPart
   private def newWsPart(wsPart: HttpProtocolWsPart) = copy(protocol = copy(protocol.copy(wsPart = wsPart)))
-  def wsBaseURL(url: String) = newWsPart(protocol.wsPart.copy(wsBaseURLs = List(url)))
-  def wsBaseURLs(urls: String*) = newWsPart(protocol.wsPart.copy(wsBaseURLs = urls.toList))
-  def wsBaseURLs(urls: List[String]) = newWsPart(protocol.wsPart.copy(wsBaseURLs = urls))
+  def wsBaseURL(url: String) = newWsPart(protocol.wsPart.copy(wsBaseURLs = List(Uri.create(url))))
+  def wsBaseURLs(urls: String*): HttpProtocolBuilder = wsBaseURLs(urls.toList)
+  def wsBaseURLs(urls: List[String]): HttpProtocolBuilder = newWsPart(protocol.wsPart.copy(wsBaseURLs = urls.map(Uri.create)))
   def wsReconnect = newWsPart(protocol.wsPart.copy(reconnect = true))
   def wsMaxReconnects(max: Int) = newWsPart(protocol.wsPart.copy(maxReconnects = Some(max)))
 

gatling-http/src/main/scala/io/gatling/http/request/builder/HttpRequestExpressionBuilder.scala

@@ -34,12 +34,12 @@ import org.asynchttpclient.request.body.multipart.StringPart
 class HttpRequestExpressionBuilder(commonAttributes: CommonAttributes, httpAttributes: HttpAttributes, httpComponents: HttpComponents)
     extends RequestExpressionBuilder(commonAttributes, httpComponents) {
 
-  def makeAbsolute(url: String): Validation[String] =
+  def makeAbsolute(url: String): Validation[Uri] =
     if (HttpHelper.isAbsoluteHttpUrl(url))
-      url.success
+      Uri.create(url).success
     else
       protocol.baseURL match {
-        case Some(baseURL) => (baseURL + url).success
+        case Some(baseURL) => Uri.create(baseURL, url).success
         case _             => s"No protocol.baseURL defined but provided url is relative : $url".failure
       }
 

gatling-http/src/main/scala/io/gatling/http/request/builder/RequestExpressionBuilder.scala

@@ -46,23 +46,19 @@ abstract class RequestExpressionBuilder(commonAttributes: CommonAttributes, http
   val httpCaches = httpComponents.httpCaches
   protected val charset = httpComponents.httpEngine.configuration.core.charset
 
-  def makeAbsolute(url: String): Validation[String]
+  def makeAbsolute(url: String): Validation[Uri]
 
-  def buildURI(session: Session): Validation[Uri] = {
-
-      def createURI(url: String): Validation[Uri] =
-        try
-          Uri.create(url).success
-        catch {
+  def buildURI(session: Session): Validation[Uri] =
+    commonAttributes.urlOrURI match {
+      case Left(url) =>
+        try {
+          url(session).flatMap(makeAbsolute)
+        } catch {
           // don't use safe in order to save lambda instances
           case NonFatal(e) => s"url $url can't be parsed into a URI: ${e.getMessage}".failure
         }
-
-    commonAttributes.urlOrURI match {
-      case Left(url)  => url(session).flatMap(makeAbsolute).flatMap(createURI)
       case Right(uri) => uri.success
     }
-  }
 
   def configureAddressNameResolver(session: Session, httpCaches: HttpCaches)(requestBuilder: AHCRequestBuilder): AHCRequestBuilder = {
     if (!protocol.enginePart.shareDnsCache) {

gatling-http/src/main/scala/io/gatling/http/request/builder/sse/SseRequestExpressionBuilder.scala

@@ -33,12 +33,12 @@ class SseRequestExpressionBuilder(commonAttributes: CommonAttributes, httpCompon
     super.configureRequestBuilder(session, uri, requestBuilder)
   }
 
-  def makeAbsolute(url: String): Validation[String] =
+  def makeAbsolute(url: String): Validation[Uri] =
     if (HttpHelper.isAbsoluteHttpUrl(url))
-      url.success
+      Uri.create(url).success
     else
       protocol.baseURL match {
-        case Some(baseURL) => (baseURL + url).success
+        case Some(baseURL) => Uri.create(baseURL, url).success
         case _             => s"No protocol.baseURL defined but provided url is relative : $url".failure
       }
 }

gatling-http/src/main/scala/io/gatling/http/request/builder/ws/WsRequestExpressionBuilder.scala

@@ -20,15 +20,17 @@ import io.gatling.http.protocol.HttpComponents
 import io.gatling.http.request.builder.{ RequestExpressionBuilder, CommonAttributes }
 import io.gatling.http.util.HttpHelper
 
+import org.asynchttpclient.uri.Uri
+
 class WsRequestExpressionBuilder(commonAttributes: CommonAttributes, httpComponents: HttpComponents)
     extends RequestExpressionBuilder(commonAttributes, httpComponents) {
 
-  def makeAbsolute(url: String): Validation[String] =
+  def makeAbsolute(url: String): Validation[Uri] =
     if (HttpHelper.isAbsoluteWsUrl(url))
-      url.success
+      Uri.create(url).success
     else
       protocol.wsPart.wsBaseURL match {
-        case Some(baseURL) => (baseURL + url).success
+        case Some(baseURL) => Uri.create(baseURL, url).success
         case _             => s"No protocol.baseURL defined but provided url is relative : $url".failure
       }
 }