Refactorings for authentication, TestType added to Bombardier options, readme file updated

mihaj · mihaj · commit a35474d32ade · 2020-10-26T15:14:52.000+01:00
diff --git a/README.md b/README.md
@@ -1,9 +1,100 @@
 # QAToolKit.Engine.Bombardier
 ![.NET Core](https://github.com/qatoolkit/qatoolkit-engine-bombardier-net/workflows/.NET%20Core/badge.svg?branch=main)
 
-QAToolKit Bombardier engine for load testing.
+`QAToolKit.Engine.Bombardier` is a .NET standard library, which takes `IList<HttpTestRequest>` object and runs load tests with tool called [Bombardier](https://github.com/codesenberg/bombardier).
 
-# License
+Library is a thin wrapper, that generates requests and parses results so you can export them to whatever format you prefer.
+
+Major features:
+
+- Library takes `IList<HttpTestRequest>` object, which can be produced in your code or can be imported from other sources. One example can be QAToolKit Swagger library that can produce that object with many options. Check it out [here](https://github.com/qatoolkit/qatoolkit-source-swagger-net).
+- Generate a Bombardier report that can be exported to the format you want.
+
+## Sample
+
+```csharp
+
+//Instantiate a Bombardier test generator, by specifying Bombardier options
+var bombardierTestsGenerator = new BombardierTestsGenerator(options =>
+{
+    //if your api endpoints you are testing are protected by Oauth2 access tokens
+    options.AddOAuth2Token("eyJhbGciOiJSUzI1N....", AuthenticationType.Customer);
+    //if your api endpoints are protected by simple "ApiKey: <apikey>" authentication header
+    options.AddApiKey("myAPIKey123423456");
+    //if your api endpoints are protected by basic authentication
+    options.AddBasicAuthentication("username", "password");
+    options.BombardierConcurrentUsers = 1;
+    options.BombardierDuration = 1;
+    options.BombardierTimeout = 30;
+    options.BombardierUseHttp2 = true;
+});
+//Generate Bombardier Tests
+var bombardierTests = await bombardierTestsGenerator.Generate(requests);
+
+//Run Bombardier Tests
+var bombardierTestsRunner = new BombardierTestsRunner(bombardierTests.ToList());
+var bombardierResults = await bombardierTestsRunner.Run();
+```
+
+Results sample `bombardierResults`:
+
+```json
+[
+    {
+        "TestStart": "2020-10-26T14:53:41.9558275+01:00",
+        "TestStop": "2020-10-26T14:53:45.371211+01:00",
+        "Duration": 3.4153835,
+        "Command": "-m GET https://api.demo.com/v1/categories?parent=4 -c 1 -H \"Authorization: Bearer eyJhbGciOiJSUzI1N....\" --http2 --timeout=30s --duration=1s",
+        "Counter1xx": 0,
+        "Counter2xx": 48,
+        "Counter3xx": 0,
+        "Counter4xx": 0,
+        "Counter5xx": 0,
+        "AverageLatency": 63.58,
+        "AverageRequestsPerSecond": 15.72,
+        "MaxLatency": 215.50,
+        "MaxRequestsPerSecond": 53.13,
+        "StdevLatency": 25.83,
+        "StdevRequestsPerSecond": 18.80
+    },
+    ...
+]
+```
+
+As you can see you get a lot of metrics from the tests.
+
+## Description
+
+#### 1. Authentication options
+
+##### 1.1 AddOAuth2Token (prefered)
+Use `AddOAuth2Token` if your APIs are protected by Oauth2 Authentication. Pass Bearer token in the method along with the `AuthenticationType`.
+
+##### 1.2 AddApiKey
+Use `AddApiKey` if your APIs are protected by simple API Key. Pass Api Key in the method. An `ApiKey` HTTP header will be generated with the value you provided. This is not best practice, but it's here if you need it.
+
+##### 1.3 AddBasicAuthentication
+Use `AddBasicAuthentication` if your APIs are protected by basic authentication. Pass username and password in the method. A basic `Authentication` HTTP header will be generated. This is not best practice, but it's here if you need it.
+
+#### 2. Bombardier parameters
+
+You can set 5 Bombardier properties:
+
+- `BombardierConcurrentUsers`: How many concurrent users should be used in Bombardier tests.
+- `BombardierDuration`: How long the Bombardier tests should execute in seconds. Use this depending on the type of test you want to perform and should not be used with `BombardierRateLimit`.
+- `BombardierTimeout`: What is the Bombardier timeout to wait for the requests to finish.
+- `BombardierUseHttp2`: Use HTTP2?
+- `BombardierRateLimit`: Rate limit Bombardier tests per second. Use this depending on the type of test you want to perform and should not be used with `BombardierDuration`.
+
+## How to use
+
+TO-DO
+
+## TO-DO
+
+- results obfuscation (authentication headers)
+
+## License
 
 MIT License
 
diff --git a/src/QAToolKit.Engine.Bombardier/BombardierOptions.cs b/src/QAToolKit.Engine.Bombardier/BombardierOptions.cs
@@ -1,24 +1,55 @@
 ﻿using QAToolKit.Core.Models;
+using System.Collections.Generic;
 
 namespace QAToolKit.Engine.Bombardier
 {
     public class BombardierOptions
     {
-        internal string CustomerAccessToken { get; set; }
-        internal string AdministratorAccessToken { get; private set; }
+        internal Dictionary<AuthenticationType, string> AccessTokens { get; private set; } = new Dictionary<AuthenticationType, string>();
         internal string ApiKey { get; private set; }
+        internal string UserName { get; private set; }
+        internal string Password { get; private set; }
         public int BombardierConcurrentUsers { get; set; }
         public int BombardierTimeout { get; set; }
         public int BombardierDuration { get; set; }
         public int BombardierRateLimit { get; set; }
         public bool BombardierUseHttp2 { get; set; }
+        internal TestType TestType { get; } = TestType.LoadTest;
 
-        public BombardierOptions AddTokensAndApiKeys(string customerToken, string adminToken, string apiKey)
+        /// <summary>
+        /// Add Oauth2 token to the bombardier generator
+        /// </summary>
+        /// <param name="token"></param>
+        /// <param name="authenticationType"></param>
+        /// <returns></returns>
+        public BombardierOptions AddOAuth2Token(string token, AuthenticationType authenticationType)
+        {
+            AccessTokens.Add(authenticationType, token);
+            return this;
+        }
+
+        /// <summary>
+        /// Add api key to the bombardier generator
+        /// </summary>
+        /// <param name="apiKey"></param>
+        /// <returns></returns>
+        public BombardierOptions AddApiKey(string apiKey)
         {
-            CustomerAccessToken = customerToken;
-            AdministratorAccessToken = adminToken;
             ApiKey = apiKey;
             return this;
         }
+
+        /// <summary>
+        /// Add basic authentication to Bombardier generator
+        /// </summary>
+        /// <param name="userName"></param>
+        /// <param name="password"></param>
+        /// <returns></returns>
+        public BombardierOptions AddBasicAuthentication(string userName, string password)
+        {
+            UserName = userName;
+            Password = password;
+            return this;
+        }
     }
 }
diff --git a/src/QAToolKit.Engine.Bombardier/BombardierResult.cs b/src/QAToolKit.Engine.Bombardier/BombardierResult.cs
@@ -1,9 +1,13 @@
 ﻿using QAToolKit.Core.Interfaces;
+using System;
 
 namespace QAToolKit.Engine.Bombardier
 {
     public class BombardierResult : ILoadTestResult
     {
+        public DateTime TestStart { get; set; }
+        public DateTime TestStop { get; set; }
+        public double Duration { get; set; }
         public string Command { get; set; }
         public int Counter1xx { get; set; }
         public int Counter2xx { get; set; }
diff --git a/src/QAToolKit.Engine.Bombardier/BombardierTestsGenerator.cs b/src/QAToolKit.Engine.Bombardier/BombardierTestsGenerator.cs
@@ -1,9 +1,11 @@
-﻿using QAToolKit.Core.Interfaces;
+﻿using QAToolKit.Core.Helpers;
+using QAToolKit.Core.Interfaces;
 using QAToolKit.Core.Models;
 using QAToolKit.Engine.Bombardier.Helpers;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
@@ -40,10 +42,9 @@ public async Task<IEnumerable<BombardierTest>> Generate(IList<HttpTestRequest> r
                 bombardierFullPath = Path.Combine("./bombardier", "linux", "bombardier");
             }
 
-            foreach (var request in restRequests)
+            foreach (var request in restRequests.Where(request => request.TestTypes.Contains(_bombardierOptions.TestType)))
             {
-                string authHeader = GeneratorHelper.GenerateAuthHeader(request, _bombardierOptions.CustomerAccessToken,
-                    _bombardierOptions.AdministratorAccessToken, _bombardierOptions.ApiKey);
+                string authHeader = GeneratorHelper.GenerateAuthHeader(request, _bombardierOptions);
 
                 scriptBuilder.AppendLine($"{bombardierFullPath} " +
                     $"-m {request.Method.ToString().ToUpper()} {GeneratorHelper.GenerateUrlParameters(request)} " +
diff --git a/src/QAToolKit.Engine.Bombardier/BombardierTestsRunner.cs b/src/QAToolKit.Engine.Bombardier/BombardierTestsRunner.cs
@@ -33,6 +33,7 @@ public async Task<IList<BombardierResult>> Run()
 
         private async Task<BombardierResult> Run(string testCommand)
         {
+            var testStart = DateTime.Now;
             var indexOfDelimiter = testCommand.IndexOf("-m");
             var bombardierExecutable = testCommand
                 .Substring(0, indexOfDelimiter - 1);
@@ -66,7 +67,8 @@ private async Task<BombardierResult> Run(string testCommand)
             //Delete temp files
             DeleteBodyFile(bombardierArguments);
 
-            var parsedBombardierOutput = ParseOutput(bombardrierOutput, bombardierArguments);
+            var testStop = DateTime.Now;
+            var parsedBombardierOutput = ParseOutput(bombardrierOutput, bombardierArguments, testStart, testStop);
 
             return parsedBombardierOutput;
         }
@@ -85,11 +87,16 @@ private void DeleteBodyFile(string arguments)
             catch { }
         }
 
-        private BombardierResult ParseOutput(StringBuilder sb, string command)
+        private BombardierResult ParseOutput(StringBuilder sb, string command, DateTime testStart, DateTime testStop)
         {
             try
             {
-                var results = new BombardierResult();
+                var results = new BombardierResult
+                {
+                    TestStart = testStart,
+                    TestStop = testStop,
+                    Duration = testStop.Subtract(testStart).TotalSeconds
+                };
 
                 var str = sb.ToString();
 
diff --git a/src/QAToolKit.Engine.Bombardier/Helpers/GeneratorHelper.cs b/src/QAToolKit.Engine.Bombardier/Helpers/GeneratorHelper.cs
@@ -5,6 +5,7 @@
 using System.IO;
 using System.Linq;
 using System.Net.Http;
+using System.Text;
 using System.Text.Json;
 
 namespace QAToolKit.Engine.Bombardier.Helpers
@@ -100,32 +101,86 @@ internal static string GenerateJsonBody(HttpTestRequest request)
         /// <param name="administratorAccessToken"></param>
         /// <param name="apiKey"></param>
         /// <returns></returns>
-        internal static string GenerateAuthHeader(HttpTestRequest request, string customerAccessToken, string administratorAccessToken, string apiKey)
+        internal static string GenerateAuthHeader(HttpTestRequest request, BombardierOptions bombardierOptions)
         {
             //Check if Swagger operation description contains certain auth tags
             string authHeader;
             if (request.Description.Contains(AuthenticationType.Oauth2.Value()))
             {
                 if (request.Description.Contains(AuthenticationType.Customer.Value()) && !request.Description.Contains(AuthenticationType.Administrator.Value()))
                 {
-                    authHeader = $"-H \"Authorization: Bearer {customerAccessToken}\" ";
+                    authHeader = GetOauth2AuthenticationHeader(bombardierOptions.AccessTokens, AuthenticationType.Customer);
                 }
                 else if (!request.Description.Contains(AuthenticationType.Customer.Value()) && request.Description.Contains(AuthenticationType.Administrator.Value()))
                 {
-                    authHeader = $"-H \"Authorization: Bearer {administratorAccessToken}\" ";
+                    authHeader = GetOauth2AuthenticationHeader(bombardierOptions.AccessTokens, AuthenticationType.Administrator);
                 }
                 else
                 {
-                    authHeader = $"-H \"Authorization: Bearer {customerAccessToken}\" ";
+                    authHeader = GetOauth2AuthenticationHeader(bombardierOptions.AccessTokens, AuthenticationType.Customer);
                 }
             }
             else if (request.Description.Contains(AuthenticationType.ApiKey.Value()))
             {
-                authHeader = $"-H \"ApiKey: {apiKey}\" ";
+                authHeader = GetApiKeyAuthenticationHeader(bombardierOptions);
+            }
+            else if (request.Description.Contains(AuthenticationType.Basic.Value()))
+            {
+                authHeader = GetBasicAuthenticationHeader(bombardierOptions);
+            }
+            else
+            {
+                authHeader = String.Empty;
+            }
+
+            return authHeader;
+        }
+
+        internal static string GetOauth2AuthenticationHeader(Dictionary<AuthenticationType, string> accessTokens, AuthenticationType authenticationType)
+        {
+            string authHeader;
+            if (accessTokens.ContainsKey(authenticationType))
+            {
+                accessTokens.TryGetValue(authenticationType, out var value);
+                authHeader = $"-H \"Authorization: Bearer {value}\" ";
+            }
+            else
+            {
+                throw new Exception("One of the access token is missing.");
+            }
+
+            return authHeader;
+        }
+
+        internal static string GetBasicAuthenticationHeader(BombardierOptions bombardierOptions)
+        {
+            string authHeader;
+
+            if (string.IsNullOrEmpty(bombardierOptions.UserName) && string.IsNullOrEmpty(bombardierOptions.Password))
+            {
+                string credentials = Convert.ToBase64String(ASCIIEncoding.ASCII.GetBytes(bombardierOptions.UserName + ":" + bombardierOptions.Password));
+
+                authHeader = $"-H \"Authorization: Basic {credentials}\" ";
+            }
+            else
+            {
+                authHeader = String.Empty;
+            }
+
+            return authHeader;
+        }
+
+        internal static string GetApiKeyAuthenticationHeader(BombardierOptions bombardierOptions)
+        {
+            string authHeader;
+
+            if (string.IsNullOrEmpty(bombardierOptions.ApiKey))
+            {
+                authHeader = $"-H \"ApiKey: {bombardierOptions.ApiKey}\" ";
             }
             else
             {
-                authHeader = "";
+                authHeader = String.Empty;
             }
 
             return authHeader;

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,13 @@`
`1`	`1`	`using QAToolKit.Core.Interfaces;`
	`2`	`+using System;`
`2`	`3`
`3`	`4`	`namespace QAToolKit.Engine.Bombardier`
`4`	`5`	`{`
`5`	`6`	`public class BombardierResult : ILoadTestResult`
`6`	`7`	`{`
	`8`	`+ public DateTime TestStart { get; set; }`
	`9`	`+ public DateTime TestStop { get; set; }`
	`10`	`+ public double Duration { get; set; }`
`7`	`11`	`public string Command { get; set; }`
`8`	`12`	`public int Counter1xx { get; set; }`
`9`	`13`	`public int Counter2xx { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ public async Task<IList<BombardierResult>> Run()`
`33`	`33`
`34`	`34`	`private async Task<BombardierResult> Run(string testCommand)`
`35`	`35`	`{`
	`36`	`+ var testStart = DateTime.Now;`
`36`	`37`	`var indexOfDelimiter = testCommand.IndexOf("-m");`
`37`	`38`	`var bombardierExecutable = testCommand`
`38`	`39`	`.Substring(0, indexOfDelimiter - 1);`
`@@ -66,7 +67,8 @@ private async Task<BombardierResult> Run(string testCommand)`
`66`	`67`	`//Delete temp files`
`67`	`68`	`DeleteBodyFile(bombardierArguments);`
`68`	`69`
`69`		`- var parsedBombardierOutput = ParseOutput(bombardrierOutput, bombardierArguments);`
	`70`	`+ var testStop = DateTime.Now;`
	`71`	`+ var parsedBombardierOutput = ParseOutput(bombardrierOutput, bombardierArguments, testStart, testStop);`
`70`	`72`
`71`	`73`	`return parsedBombardierOutput;`
`72`	`74`	`}`
`@@ -85,11 +87,16 @@ private void DeleteBodyFile(string arguments)`
`85`	`87`	`catch { }`
`86`	`88`	`}`
`87`	`89`
`88`		`- private BombardierResult ParseOutput(StringBuilder sb, string command)`
	`90`	`+ private BombardierResult ParseOutput(StringBuilder sb, string command, DateTime testStart, DateTime testStop)`
`89`	`91`	`{`
`90`	`92`	`try`
`91`	`93`	`{`
`92`		`- var results = new BombardierResult();`
	`94`	`+ var results = new BombardierResult`
	`95`	`+ {`
	`96`	`+ TestStart = testStart,`
	`97`	`+ TestStop = testStop,`
	`98`	`+ Duration = testStop.Subtract(testStart).TotalSeconds`
	`99`	`+ };`
`93`	`100`
`94`	`101`	`var str = sb.ToString();`
`95`	`102`