Project roadmap

[Mielek]

We are happy to present our roadmap for the project. Below you can find current milestones which we would like to achieve and estimated time of arrival. Every milestone will be concluded with the library release.

Please let us now if you like the roadmap and if there are different features which we should consider.

Implement all policies currently available in APIM to compiler

Milestone ETA: Mar 2025 - MVP summit

We plan to implement the rest of the policies to the compiler. We think having all currently available policies in the toolkit will allow users to start migrating to C# base policies. Thanks to that we would be able to call the compiler production ready.

Milestone will also include:

1. Release policy toolkit in NuGet
   Toolkit is delivered to users as a set of .NET packages. Users need to download them from GitHub or build them from the source. Libraries sharing standard for .Net is NuGet. Adding Policy Toolkit libraries in NuGet should make it easier for users to download and test the toolkit.
2. Logging in compiler for debugging issues
   The compiler has a very limited number of logs which it produces. This makes issues with the compiler much harder to understand and debug. To help users and us understand issues with the compiler we need to provide a comprehensive set of logs, enabled by flag.

Policy section emulation

Milestone ETA: May 2025 - Microsoft Build

We plan to add necessary emulation and mocking which would allow users to create unit tests for policy sections (inbound, backend, outbound and on-error) in C#. This milestone would allow customers to test policy section with request or response. In the milestone not all policies will be implemented in the emulator.

With this milestone user will be able to:

• Create a gateway context for tests using C# library API.
• Supply values to the context, like method, API, operation, variable etc.
• Mock whole polices, and/or their specific behavior.
• Supply other runtime states like name values, certificates, etc.
• Run policy section with created context.
• Inspect and assert context after section code would run.

Example of test:

void Test()
{
  //Assume
  var document = new MyPolicyDocument();
  var gatewayContext = new GatewayContext()
  {
    Request = { Headers = { {"X-TO-REMOVE", ["value"]} } }
    NameValues = { {"miclientid", "04658f68-e074-47c0-b596-672468448723"} }    
  };
  gatewayContext.MockPolicy().AuthenticationManagedIdentity().ReturnsToken("MockedToken");

  // Act
  document.Inbound(gatewayContext.AsInbound());

  // Assert
  Assert.IsFalse(gatewayContext.Request.Headers.ContainsKey("X-TO-REMOVE"));
  var authHeaderValue = gatewayContext.Request.Headers.GetValueOrDefault("Authorization");
  Assert.IsNotNull(authHeaderValue);
  Assert.AreEqual("Beared MockedToken", authHeaderValue);
}

Policy pipeline emulation

Milestone ETA: Jul 2025

We plan to add necessary features to the emulator which would allow users to create unit tests with the whole policy pipeline. This milestone would allow customers to test requests going through prepared pipelines and assert response it returns.

User will be able to:

• Create policy pipeline from selected policies.
• Mock external services like EntraId or API backend by creating response for them
• Create and run requests through policy pipeline.
• Inspect and assert requests to external services
• Inspect and assert pipeline response

Milestone will also include:

• Logging in compiler for pipelines
  Compiler should be used in the scripts and CI/CD pipelines. We need to make sure that the compiler will have an option to produce its output, a format which would be better for these uses.
• Implementation some of most requested or used policies to emulator
  This addresses the gap between available policies in emulator in Azure API Management and Policy Toolkit.

Pseudocode for policy pipeline testing:

void Test()
{
  //Assume
  var pipeline = new TestPipeline(
    new GlobalPolicy(),
    new ProductPolicy(),
    new ApiPolicy(),
    new ApiOperationPolicy()            
  );
  var gatewayContext = new GatewayContext()
  {
    Request = HttpTestUtil.LoadRequest("./api/client-request.http"),
    NameValues = { {"miclientid", "04658f68-e074-47c0-b596-672468448723"} }    
  };
  gatewayContext.MockPolicy().ForwardRequest(id = "some-id").ForRequest("api/backend-request.http").ReturnResponse("./api/backend-response.http");

  // Act
  pipeline.Run(gatewayContext)

  // Assert
  var response = HttpTestUtil.LoadResponse("./api/expected-response.http");
  Assert.AreEqual(response, gatewayContext.Response);
}

Future Features

Features which we consider doing next after current milestones are finished.

APIOps integration

We plan to add necessary features to the emulator which would allow users to fully integrate emulator with APIOps. This milestone would allow customers to test whole gateway configuration with a request/response specification. Resolution of policy pipeline would be done automatically for every test request.

User will be able to:

• Load and manage gateway runtime assets for tests, like APIs, name values.
• Connect entities which contain policy documents with C# policy documents.
• Mock external services like EntraId or API Backend
• Create tests which would check if the given request will produce the expected response.

Support for policy fragments

Azure API Management has a policy fragment functionality. It allows users to extract parts of the policy and reuse it in multiple documents. Policy toolkit should allow creation of policy fragments. We should allow easy reusage of the fragments and emulate the call to the fragments. Usage of fragments should automatically be changed to include-fragment policy when compiled.

Run tests on live Azure API Management service

In this milestone we would like to allow changing target of the test created for the APIOps feature to run on live Azure API Management service. This feature would allow users to have one set of tests which would be able to run on emulated and on actual gateway.

Telemetry in compiler

Policy toolkit relays on the GitHub repository stars, forks, watches and release downloads to measure adoption of the project. We would like to introduce basic, non-intrusive telemetry in the compiler to have more information about the usage.

[kyl3t]

Following up on the "Milestone ETA: Mar 2025 - MVP summit" milestone. Is there a date in sight for publishing this tool to Nuget? Thanks

[Mielek]

Hello @kyl3t ! This is our top priority. We are now doing finishing touches to the code. We expect release in GitHub to be available by the end of this week. Release in nuget will take us little bit more time, because we are discovering release process for official Microsoft packages. We are expecting that work to be done, and packages to be available in nuget by the end of April.

[kyl3t]

Thanks for the update @Mielek