Bombardier Insecure flag support, use content type support, refactorings and bug fixes

Author: mihaj

Directory.Build.props

@@ -1,5 +1,5 @@
 <Project>
   <PropertyGroup>
-    <Version>0.1.0</Version>
+    <Version>0.1.1</Version>
   </PropertyGroup>
 </Project>

src/QAToolKit.Engine.Bombardier.Test/BombardierTestsGeneratorTests.cs

@@ -0,0 +1,40 @@
+using Newtonsoft.Json;
+using QAToolKit.Core.Models;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace QAToolKit.Engine.Bombardier.Test
+{
+    public class BombardierTestsGeneratorTests
+    {
+       /* [Fact]
+        public async Task BombardierTestWithoutOptionsTest_Successfull()
+        {
+
+            var bombardierTestsGenerator = new BombardierTestsGenerator(options =>
+            {
+                options.BombardierConcurrentUsers = 1;
+                options.BombardierDuration = 1;
+                options.BombardierTimeout = 30;
+                options.BombardierUseHttp2 = true;
+            });
+
+            var content = File.ReadAllText("d:\\getPetById.json");
+            var httpRequest = JsonConvert.DeserializeObject<IList<HttpTestRequest>>(content);
+
+            var bombardierTests = await bombardierTestsGenerator.Generate(httpRequest);
+
+            //Run Bombardier Tests
+            var bombardierTestsRunner = new BombardierTestsRunner(bombardierTests.ToList(), options =>
+            {
+                options.ObfuscateAuthenticationHeader = true;
+            });
+            var bombardierResults = await bombardierTestsRunner.Run();
+
+            Assert.NotNull(bombardierResults);
+        }*/
+    }
+}

src/QAToolKit.Engine.Bombardier.Test/QAToolKit.Engine.Bombardier.Test.csproj

@@ -19,4 +19,8 @@
     </PackageReference>
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\QAToolKit.Engine.Bombardier\QAToolKit.Engine.Bombardier.csproj" />
+  </ItemGroup>
+
 </Project>

src/QAToolKit.Engine.Bombardier.Test/UnitTest1.cs

@@ -45,6 +45,14 @@ public class BombardierGeneratorOptions
         /// </summary>
         public bool BombardierUseHttp2 { get; set; }
         /// <summary>
+        /// Use http or https protocols, default is false.
+        /// </summary>
+        public bool BombardierInsecure { get; set; } = false;
+        /// <summary>
+        /// Set request body content type for Bombardier tests, default is 'application/json'
+        /// </summary>
+        public string BombardierBodyContentType { get; set; } = "application/json";
+        /// <summary>
         /// What is the type of the test
         /// </summary>
         internal TestType TestType { get; } = TestType.LoadTest;

src/QAToolKit.Engine.Bombardier/BombardierGeneratorOptions.cs

@@ -48,19 +48,20 @@ public async Task<IEnumerable<BombardierTest>> Generate(IList<HttpTestRequest> r
                 bombardierFullPath = Path.Combine("./bombardier", "linux", "bombardier");
             }
 
-            foreach (var request in restRequests.Where(request => request.TestTypes.Contains(_bombardierGeneratorOptions.TestType)))
+            foreach (var request in restRequests)
             {
                 string authHeader = GeneratorHelper.GenerateAuthHeader(request, _bombardierGeneratorOptions);
 
                 scriptBuilder.AppendLine($"{bombardierFullPath} " +
                     $"-m {request.Method.ToString().ToUpper()} {GeneratorHelper.GenerateUrlParameters(request)} " +
                     $"-c {_bombardierGeneratorOptions.BombardierConcurrentUsers} " +
                     $"{authHeader}" +
-                    $"{GeneratorHelper.GenerateContentTypeHeader(request)}" +
-                    $"{GeneratorHelper.GenerateJsonBody(request)}" +
+                    $"{GeneratorHelper.GenerateContentTypeHeader(request, _bombardierGeneratorOptions.BombardierBodyContentType)}" +
+                    $"{GeneratorHelper.GenerateJsonBody(request, _bombardierGeneratorOptions.BombardierBodyContentType)}" +
                     $"--{(Convert.ToBoolean(_bombardierGeneratorOptions.BombardierUseHttp2) ? "http2" : "http1")} " +
                     $"--timeout={_bombardierGeneratorOptions.BombardierTimeout}s " +
                     $"--duration={_bombardierGeneratorOptions.BombardierDuration}s " +
+                    $"{GeneratorHelper.GenerateInsecureSwitch(_bombardierGeneratorOptions)}" +
                     $"{GeneratorHelper.GenerateRateLimit(_bombardierGeneratorOptions.BombardierRateLimit)}");
 
                 bombardierTests.Add(new BombardierTest()

src/QAToolKit.Engine.Bombardier/BombardierTestsGenerator.cs

@@ -1,4 +1,5 @@
 using Microsoft.AspNetCore.WebUtilities;
+using QAToolKit.Core.Helpers;
 using QAToolKit.Core.Models;
 using System;
 using System.Collections.Generic;
@@ -22,26 +23,34 @@ internal static string GenerateRateLimit(int rateLimit)
             {
                 return $"--rate={rateLimit}";
             }
-            else
-            {
-                return "";
-            }
+
+            return String.Empty;
         }
 
         /// <summary>
         /// Generate content type header
         /// </summary>
         /// <param name="request"></param>
+        /// <param name="useContentType"></param>
         /// <returns></returns>
-        internal static string GenerateContentTypeHeader(HttpTestRequest request)
+        internal static string GenerateContentTypeHeader(HttpTestRequest request, string useContentType)
         {
             if (request.Method == HttpMethod.Get)
             {
-                return "";
+                return String.Empty;
             }
             else
             {
-                return "-H \"Content-Type: application/json\" ";
+                var contentType = request.RequestBodies.FirstOrDefault(content => content.ContentType == useContentType);
+
+                if (contentType != null)
+                {
+                    return $"-H \"Content-Type: {contentType.ContentType}\" ";
+                }
+                else
+                {
+                    throw new Exception($"Content type header '{useContentType}' not found in the HttpTestRequest.");
+                }
             }
         }
 
@@ -52,8 +61,6 @@ internal static string GenerateContentTypeHeader(HttpTestRequest request)
         /// <returns></returns>
         internal static string GenerateUrlParameters(HttpTestRequest request)
         {
-            var path = request.Path;
-
             var queryParameters = new Dictionary<string, string>();
 
             //add query parameters
@@ -62,27 +69,40 @@ internal static string GenerateUrlParameters(HttpTestRequest request)
                 queryParameters.Add(parameter.Name, parameter.Value);
             }
 
-            return new Uri(new Uri(request.BasePath), QueryHelpers.AddQueryString(path, queryParameters)).ToString();
+            var baseUrl = new Uri($"{request.BasePath}{request.Path}").ToString();
+            var url = QueryHelpers.AddQueryString(baseUrl, queryParameters).ToString();
+
+            return url;
         }
 
         /// <summary>
         /// Generate JSON body
         /// </summary>
         /// <param name="request"></param>
+        /// <param name="useContentType"></param>
         /// <returns></returns>
-        internal static string GenerateJsonBody(HttpTestRequest request)
+        internal static string GenerateJsonBody(HttpTestRequest request, string useContentType)
         {
             if (request.Method == HttpMethod.Get)
             {
                 return String.Empty;
             }
             else
             {
-                if (request.RequestBody.Properties.Count > 0)
+                var useRequest = request.RequestBodies.FirstOrDefault(content => content.ContentType == useContentType);
+
+                if (useRequest == null)
                 {
-                    File.WriteAllText($"{request.RequestBody.Name}.json", JsonSerializer.Serialize(request.RequestBody.Properties));
+                    throw new Exception($"Request body content type '{useContentType}' not found in the HttpTestRequest.");
+                }
 
-                    return $"-f \"{request.RequestBody.Name}.json\" ";
+                var fileName = $"{Guid.NewGuid()}.json";
+
+                if (useRequest.Properties.Count > 0)
+                {
+                    File.WriteAllText(fileName, JsonSerializer.Serialize(useRequest.Properties));
+
+                    return $"-f \"{fileName}\" ";
                 }
                 else
                 {
@@ -91,6 +111,22 @@ internal static string GenerateJsonBody(HttpTestRequest request)
             }
         }
 
+
+        /// <summary>
+        /// Generate Insecure Bombardier switch
+        /// </summary>
+        /// <param name="bombardierOptions"></param>
+        /// <returns></returns>
+        public static string GenerateInsecureSwitch(BombardierGeneratorOptions bombardierOptions)
+        {
+            if (bombardierOptions.BombardierInsecure)
+            {
+                return "--insecure";
+            }
+
+            return String.Empty;
+        }
+
         /// <summary>
         /// Generate Authentication header for HTTP request
         /// </summary>

src/QAToolKit.Engine.Bombardier/Helpers/GeneratorHelper.cs

@@ -32,7 +32,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="Microsoft.AspNetCore.WebUtilities" Version="2.2.0" />
-		<PackageReference Include="QAToolKit.Core" Version="0.1.0" />
+		<PackageReference Include="QAToolKit.Core" Version="0.1.1" />
 		<PackageReference Include="System.Text.Json" Version="4.7.2" />
 	</ItemGroup>