Testing

• Testing Notes – Used for maintaining documentation related to the test

• Scripting – Contains the entire logic of the test

• Files – Designed for storing files linked to the test, such as test data

c#
/*

This is an example of a simple test that verifies the response structure and status codes. Such a test can be created using code generation tools:
(Code editor -> Tools -> Code generation -> !!Insert server response into Input Data!! -> Json Data to Simple Response Test (C#) -> Convert).

The test makes a call to the target request using the Query method, passing the PublicID of the request as an argument. 
It then performs checks on the status code and the response structure.

For a negative test, data in the request body, headers, or parameters is intentionally modified by changing variable values (using the AddVariable method).
This ensures that the target request is executed with incorrect input data. 
The expected result of such a test is a server response with a status code indicating a client error.
The tests also verify the response time.

*/

//entry point
public async Task RunTests()
{
    // positive test
    await RunPositiveTestForResponse();
    // negative test
    await RunNegativeTestForResponse();                                                              
}

//Testing query PublicID
private string GetQueryId() => "PUT_YOUR_TEMPLATE_ID_HERE";


//Positive test
public async Task RunPositiveTestForResponse()
{
    await Testing("Test positive example", async test =>. // Definition of the testing scope with name "Test positive example"
    {
         var  templateResponse = await Query(GetQueryId()); // Call to the tested query 
                               
    
         await test.WithStep("Status code validation") // Definition of a testing step with name "Status code validation"
                   .AssertIsTrue(templateResponse.IsGood()); //Status code validation -  Statuses 400-499
                   
         await test.WithStep("Response structure validation") // Definition of a testing step with name "Response structure validation"
                            .AssertIsValidJson(templateResponse.RawBody, GetJsonSchema()); // Validation of the response structure against a JSON schema
        
         
         await test.WithStep("Execution time validation (timeout 30 sec)")  // Definition of a testing step with name "Execution time validation (timeout 30 sec)"
                                .AssertExecutionTime(TimeSpan.FromSeconds(30), templateResponse.ExecutionTime); // Execution time validation
        
    });   
}

//Negative test
public async Task RunNegativeTestForResponse()
{
    await Testing("Test negative example", async test => // Definition of the testing scope with name "Test negative example"
    {
    
      var  templateResponse = await Query(GetQueryId(), // Call to the tested query 
                                              v=> v.AddVariable("PARAMETER_A","WRONG_VALUE_1"),  // Setting incorrect parameters to trigger a client error
                                              v=> v.AddVariable("PARAMETER_B","WRONG_VALUE_2"),  // Setting incorrect parameters to trigger a client error
                                              v=> v.AddVariable("PARAMTER_C","WRONG_VALUE_3"));  // Setting incorrect parameters to trigger a client error
                                              
          await test.WithStep("Status code validation") // Definition of a testing step with name "Status code validation"
                               .AssertIsTrue(templateResponse.IsClientErrors()); // Status code validation -  Statuses 400-499
                               
          await test.WithStep("Execution time validation (timeout 30 sec)")  // Definition of a testing step with name "Execution time validation (timeout 30 sec)"
                                  .AssertExecutionTime(TimeSpan.FromSeconds(30), templateResponse.ExecutionTime); // Execution time validation
        
    });   
}

public string GetJsonSchema() => "PUT YOUR JSON SCHEMA HERE"; // JSON Schema

c#
//Positive
var positiveResponse = await RunTemplate("TemplateID", v=>v.AddVariable("token",token));
//Negative
var negativeResponse = await RunTemplate("TemplateID", v=>v.AddVariable("wrongToken","XYNYX"));

c#
public interface IResponseModel
{
    /// <summary>
    /// Response as is
    /// </summary>
    HttpResponseMessage Response { get; set; }
    
    /// <summary>
    /// Response headers wrapped in HeaderModel
    /// </summary>
    List<HeaderModel> ResponseHeader { get; set; }
    
    /// <summary>
    /// Response cookies wrapped in HeaderModel
    /// </summary>
    List<CookiesModel> ResponseCookies { get; set; }
    
    /// <summary>
    /// Stores statistical information about the execution of a query/test.
    /// </summary>
    IStatistics Statistics { get; set; }
    
    /// <summary>
    /// Stores instance of source template
    /// </summary>
    TemplateModel Template { get; set; }
    
    /// <summary>
    /// Execution time since start request
    /// </summary>
    TimeSpan ExecutionTime { get; set; }
    
    /// <summary>
    /// Stores information about an error, in case it occurs.
    /// </summary>
    Exception Exception { get; set; }
    
    /// <summary>
    /// Part of statistics info - processing output
    /// </summary>
    string QueryOutput { get; set; }
    
    /// <summary>
    /// Status code in int
    /// </summary>
    int Status { get; }
    
    /// <summary>
    /// Body RAW
    /// </summary>
    string RawBody { get; }
    
    /// <summary>
    /// Check if the status code belongs to the category: Info
    /// Status >= 100 and Status < 200
    /// </summary>
    /// <returns></returns>
    bool IsInfos();
    
    /// <summary>
    /// Check if the status code belongs to the category: Redirects
    /// Status >= 300 and Status < 400
    /// </summary>
    /// <returns></returns>
    bool IsRedirects();
    
    /// <summary>
    /// Check if the status code belongs to the category: Client Errors
    /// Status >= 400 and Status < 500
    /// </summary>
    /// <returns></returns>
    bool IsClientErrors();
    
    /// <summary>
    /// Check if the status code belongs to the category: Server Errors
    /// Status >= 500 and Status < 600
    /// </summary>
    /// <returns></returns>
    bool IsServerErrors();
    
    /// <summary>
    /// Check if the status code belongs to the category: Bad (For Lazy)
    /// Status >= 400 and Status < 600
    /// </summary>
    /// <returns></returns>
    bool IsBad();
    
    /// <summary>
    /// Check if the status code belongs to the category: Good (For Lazy)
    /// Status >= 200 and Status < 300
    /// </summary>
    /// <returns></returns>
    bool IsGood();
    
    /// <summary>
    /// Check if the status code equals 200
    /// </summary>
    /// <returns></returns>
    bool IsOk();
    
    /// <summary>
    /// Check if the status code equals 400
    /// </summary>
    /// <returns></returns>
    bool IsBadRequest();
    
    /// <summary>
    /// Check if the status code equals 404
    /// </summary>
    /// <returns></returns>
    bool IsNotFound();
    
    /// <summary>
    /// Check if the status code equals 403
    /// </summary>
    /// <returns></returns>
    bool IsForbidden();
    
    /// <summary>
    /// Check if the status code equals 401
    /// </summary>
    /// <returns></returns>
    bool IsUnauthorized();
    
    /// <summary>
    /// The method returns the raw data of the response body.
    /// </summary>
    /// <returns></returns>
    Task<JModel> GetBodyRawData();
}

c#
public interface IFileModel
{
    /// <summary>
    /// Filename 
    /// </summary>
    string Name { get; set; }
    
    /// <summary>
    /// Lenght (bytes)
    /// </summary>
    long Lenght { get; set; }
    
    /// <summary>
    /// File content
    /// </summary>
    byte[] Content { get; set; }
    
    /// <summary>
    /// Uniq id
    /// </summary>
    Guid Id { get; set; }
}

c#
var myObject = new { Name = "Dmitry", Age = 32 };

string? json = Serialize(myObject);

Log(json);

// Output:
// {
//   "Name": "Dmitry",
//   "Age": 32
// }

c#
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

await Testing("Persons test", async test => 
{
	
  var response = await Query("GetPerson");
	
  var person = Deserialize<Person>(response.RawBody); 
  
  Log(person);
  
  // Output:
	// { 
  //  	"Name": "Dmitry", 
  //		"Age": 32 
  // }
  
});

c#
class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

var schema1 = await JsonSchema<Person>();
Log(schema1);
// Output :
//{
//  "$schema": "http://json-schema.org/draft-04/schema#",
//  "type": "object",
//  "required": [
//    "Name",
//    "Age"
//  ],
//  "properties": {
//    "Name": {
//      "type": "string"
//    },
//    "Age": {
//    "type": "integer"
//   }
// }
//}

var schema2 = await JsonSchema(typeof(Person));
Log(schema2);
// Output :
//{
//  "$schema": "http://json-schema.org/draft-04/schema#",
//  "type": "object",
//  "required": [
//    "Name",
//    "Age"
//  ],
//  "properties": {
//    "Name": {
//      "type": "string"
//    },
//    "Age": {
//    "type": "integer"
//   }
// }
//}

var schema3 = await JsonSchema(Serialize(new Person()));
Log(schema3);
// Output :
//{
//  "$schema": "http://json-schema.org/draft-04/schema#",
//  "type": "object",
//  "required": [
//    "Name",
//    "Age"
//  ],
//  "properties": {
//    "Name": {
//      "type": "string"
//    },
//    "Age": {
//    "type": "integer"
//   }
// }
//}

c#
Log("Operation completed.");
// Output (in Statistics.Output):
// (UTC) 12:34:56.789 Operation completed.


//Object overload:
var person = new { Name = "Dmitry", Age = 32 };
Log(person);
// Output (in Statistics.Output):
// (UTC) 12:34:56.789 {"Name":"Dmitry","Age":32}

c#
await Testing("Test with faker", async test =>
        {

            var  fakeUser =  test.UseFaker()
                              .Setup(fakerConfig =>
                              {
                                  /* Custom rules */ 
                                
                              }).FakeObject<User>();
            
            var  fakeUsers =  test.UseFaker<User>()
                                                .Setup(x=>x.Rules((faker, user) =>
                                                {
                                                   /* Custom rules */ 
                                                  
                                                })).FakeCollection<User>(10);

            var createUserResponse = await Query("QueryTemplateForSingleUser", 
                                                    vars => vars.AddVariable("body",Serialize(fakeUser)));
            
                        
            var createMultipleUsersResponse = await Query("QueryTemplateForMultipleUsers", 
                vars => vars.AddVariable("body",Serialize(fakeUsers)));

            await test.WithStep("Single user")
                      .AssertIsTrue(createUserResponse.IsOk());
            
            await test.WithStep("Multiple users")
                .AssertIsTrue(createMultipleUsersResponse.IsOk());

        });

c#
//Custom rules can be added using the Rules method to define how each field of the object should be populated
var fakeUsers = test.UseFaker<User>()
                    .Setup(x => x.Rules((faker, user) =>
                    {
                        user.Name = faker.Person.FullName;
                        user.Email = faker.Internet.Email();
                        user.Age = faker.Random.Int(18, 60);
                    })).FakeCollection<User>(10);

// Fakers can generate nested objects as part of a parent object.
var fakeOrder = test.UseFaker<Order>()
                    .Setup(faker => faker.Rules((f, order) =>
                    {
                        order.User = f.FakeObject<User>();
                        order.Items = f.FakeCollection<Item>(5);
                    })).FakeObject<Order>();

c#
await testScope.Step("Validate user creation", async () =>
{
    var response = await Query("CreateUserQuery");
    await testScope.AssertIsTrue(response.IsOk());
});

c#
await testScope.WithStep("Validate user creation")
               .AssertIsTrue(response.IsOk());

1. string message
• The main report message.
• Can include placeholders (e.g., {0}) for formatting dynamic values.

2. double? indicatorValue (optional)
• A numeric value associated with the report entry.
• Useful for tracking metrics like execution time, step counts, or success rates.

3. string unit (optional)
• The unit of measurement for the indicatorValue.
• Examples: "ms" for milliseconds, "count" for steps, or any custom unit.

4. TrendType trendType (optional, default: Positive)
• Indicates the trend associated with the value (e.g., Positive, Negative, or Neutral).
• Helps evaluate and visualize metrics in reports.

c#
await testScope.Report("Execution time: {0} ms", 120, "ms", TrendType.Negative);

c#
if (!response.IsOk())
{
    await testScope.Fail("User creation failed: invalid response received.");
}

c#
if (response.IsOk())
{
    await testScope.Success("User creation succeeded: valid response received.");
}

c#
if (response.HasWarnings())
{
    await testScope.Warning("User creation completed with warnings: some fields were missing.");
}

c#
await testScope.ItIsCriticalTest()
               .WithStep("Validate critical user creation")
               .AssertIsTrue(response.IsOk());