Ronald's Blog

Deep Object Comparison in MSTest with Assert.AreEquivalent

Thu, 09 Jul 2026 20:00:00 +0200

MSTest v4.3.0 introduces the Assert.AreEquivalent method that performs a deep equality comparison of two objects, checking that all properties have the same value. In this post, I’ll show you what it can do and how it compares to AwesomeAssertions and Shouldly.

Grouping APIs in Azure API Management Using Tags

Mon, 23 Mar 2026 07:00:00 +0100

When you have a lot of APIs in Azure API Management, the view can become unwieldy. By applying tags to your APIs you can group and filter them in both the Azure Portal and the Developer Portal. In this post I’ll show you how to assign tags to APIs using Bicep and how to automatically bubble up operation-level tags from an OpenAPI spec to the API level.

Implement Failover in API Management with a Load-balanced Pool

Mon, 09 Mar 2026 06:00:00 +0100

In this post, I’ll show you how to implement (regional) failover in Azure API Management using priority-based load-balanced pools, backend circuit breakers and retry policies. The setup sends traffic to the local backend by default and automatically fails over to the secondary backend when the primary backend becomes unavailable.

GitHub Actions Workflow for Azure Developer CLI (azd) Templates

Mon, 02 Mar 2026 06:00:00 +0100

In this post, I’ll show how I structure a GitHub Actions workflow for Azure Developer CLI (azd) templates so I can automate the process of building, deploying, verifying and cleaning up. The workflow makes it easier to validate my own changes and review external contributions. I’ll walk through each job with practical snippets and explain why I split build, deployment and verification.

Tips and Tricks for Authoring Azure Developer CLI (azd) Templates

Mon, 23 Feb 2026 07:00:00 +0100

I’ve created several Azure Developer CLI (azd) templates over the past year. In this post, I share practical tips and tricks for authoring azd templates, including parameter management, naming conventions, hooks, pipelines and handling Entra ID resources.

Alert Processing Rules in Bicep: Add Action Groups or Suppress Notifications

Mon, 02 Feb 2026 17:45:00 +0100

Alert processing rules let you add action groups or suppress notifications without changing alert rules. In this post I explain the actionRules resource in Bicep and show two scenarios: adding an action group and suppressing notifications on a schedule for failed availability tests.

Track Availability in Application Insights using Logic App Workflow

Mon, 26 Jan 2026 17:00:00 +0100

I’ve worked with clients following a low-code first strategy where Logic Apps are preferred over .NET solutions. This post shows you how to create custom availability tests using Logic App (Standard) workflows and track the results in Application Insights. This approach gives you access to all Logic App capabilities while requiring minimal code.

Track Availability in Application Insights using .NET

Mon, 19 Jan 2026 09:00:00 +0100

Standard availability tests in Application Insights have limitations like no multi-step authentication, no mTLS support and no access to private networks. This post shows you how to create custom availability tests using .NET and Azure Functions to overcome these restrictions while gaining full control over your monitoring logic.

Track Availability in Application Insights using Standard Test

Mon, 12 Jan 2026 08:45:00 +0100

When connecting to external systems in integration projects, availability tests help you monitor system uptime, verify security measures are up to date and confirm systems can be reached. This post shows you how to create Application Insights standard tests through Bicep to automate your availability monitoring with infrastructure-as-code.

Rate Limiting in Azure API Management

Tue, 06 Jan 2026 14:00:00 +0100

Learn how to use Azure API Management’s rate-limit and rate-limit-by-key policies to protect backends from overwhelming traffic and fairly distribute capacity among clients. Includes practical examples, monitoring guidance and key considerations for different scenarios.

Catch-All API in Azure API Management: Forward Any Request

Mon, 15 Dec 2025 16:00:00 +0100

Sometimes you just want to forward any request from Azure API Management to a backend without defining a detailed API contract. In this post I show how to create a simple Catch-All API that supports multiple HTTP methods and matches any URL.

Generic Error Handling in API Management

Mon, 01 Dec 2025 17:15:00 +0100

Learn how to implement centralized error handling in Azure API Management at the global scope, reducing duplicate logic and ensuring consistent error responses across all APIs while maintaining flexibility for custom scenarios.

Sanitizing Response Headers in API Management

Mon, 24 Nov 2025 09:30:00 +0100

By default, Azure API Management returns all headers from the backend to the client, which may include sensitive information. This post demonstrates three approaches to sanitizing response headers: explicit removal, allowlist-based filtering and blocklist-based filtering.

Call OAuth-Protected APIs from Azure DevOps Using Federated Credentials

Mon, 10 Nov 2025 16:00:00 +0100

Learn how to execute automated integration tests against OAuth-protected APIs from Azure DevOps pipelines using federated credentials. This enables secure API testing without managing secrets in your CI/CD pipeline.

Call OAuth-Protected APIs from GitHub Actions Using Federated Credentials

Mon, 03 Nov 2025 16:00:00 +0100

Learn how to execute automated integration tests against OAuth-protected APIs from GitHub Actions workflows using federated credentials. This enables secure API testing without managing secrets in your CI/CD pipeline.

Call OAuth-Protected Backends from API Management using Send-Request Policy with Client Certificate

Mon, 20 Oct 2025 16:00:00 +0200

Learn how to implement certificate-based OAuth authentication in API Management using JWT assertions and the send-request policy. This approach provides stronger security than client secrets by proving possession of a private key without transmitting it.

Call OAuth-Protected Backends from API Management using Send-Request Policy with Client Secret

Mon, 13 Oct 2025 16:00:00 +0200

When API Management’s credential manager isn’t suitable for your OAuth scenarios, you can implement token handling directly using policies. In this post, I show how to call OAuth-protected backends using the send-request policy with Client Credentials Flow and a client secret stored in Key Vault.

Call OAuth-Protected Backends from API Management using Credential Manager

Mon, 06 Oct 2025 16:00:00 +0200

Azure API Management’s credential manager provides a simple, managed way to handle OAuth flows with automatic token acquisition and caching. In this post, I show how to configure it using Bicep and integrate it into your APIs. I also highlight key considerations to help you decide when credential manager is the right choice versus custom token handling.

Call OAuth-Protected APIs with Managed Identity from API Management

Mon, 29 Sep 2025 16:00:00 +0200

Learn how to use API Management to call OAuth-protected APIs with managed identity. This enables secure API-to-API communication and privilege delegation patterns without managing secrets.

Call OAuth-Protected APIs with Managed Identity from Logic Apps

Wed, 24 Sep 2025 17:00:00 +0200

Azure Logic Apps Standard makes it easy to call OAuth-protected APIs using managed identity. This post demonstrates how to use the HTTP action’s built-in authentication and token caching for secure, reliable calls.

Call OAuth-Protected APIs with Managed Identity from .NET

Sat, 20 Sep 2025 14:30:00 +0200

Learn how to call OAuth-protected APIs from .NET applications using Azure managed identity. This post shows how to implement secure API calls from Azure Functions without managing secrets, using the Azure Identity library and custom HTTP message handlers.

Protect APIs in Azure API Management with OAuth

Tue, 16 Sep 2025 19:30:00 +0200

Discover how to secure APIs in Azure API Management with OAuth 2.0 and Microsoft Entra ID using a fully automated, infrastructure-as-code approach. This post walks through deploying everything with Bicep, including app registrations via the Microsoft Graph Bicep extension, so you can avoid manual portal setup and ensure repeatable deployments.

Convert Base64 to multipart/form-data with API Management

Thu, 04 Sep 2025 18:30:00 +0200

In this post, I’ll show you how to use Azure API Management policies to transform a JSON request containing a base64-encoded file into a multipart/form-data request. This lets you connect clients that send files in JSON with backends that require standard form uploads.

Azure Integration Services Quickstart

Fri, 21 Feb 2025 11:00:00 +0100

I’ve recently published a Bicep template for quickly deploying Azure Integration Services, including Azure API Management, Function App, Logic App, Service Bus and Event Hubs namespace, along with supporting resources such as Application Insights, Key Vault and Storage Account.

Testing PSRule Rules for API Management Policies with Pester

Thu, 26 Sep 2024 16:00:00 +0200

In my previous blog post, I demonstrated how to use PSRule to validate Azure API Management policies by defining several custom rules, each with specific logic. As a fan of Test Driven Development, I created these rules following a test-first approach. In this post, I’ll walk you through how to write automated tests for these PSRule rules using Pester, a popular testing framework for PowerShell.

Validate API Management policies with PSRule

Mon, 02 Sep 2024 19:30:00 +0200

I’ve been working with Azure API Management for a while now, and one of the challenges I’ve faced is finding a reliable way to validate the XML policies I write. While tools like SonarQube are excellent for code quality checks, they don’t support the specific checks required for Azure API Management policies. In this blog post, I’ll demonstrate how to use PSRule to validate your Azure API Management policies effectively.

Reqnroll Parsable Value Retriever and Comparer

Wed, 17 Jul 2024 08:00:00 +0200

In this blog post, we’ll explore how to use the IParsable<T> interface to build a generic Reqnroll value retriever and comparer. We’ll start by creating custom value retrievers and comparers, then develop a reusable solution with generics, and finally, we’ll use reflection to make it even more generic. (This solution also works for its predecessor, SpecFlow, when using .NET 7 or higher.)

Replace placeholders in string with user-defined Bicep function

Fri, 21 Jun 2024 15:00:00 +0200

When you have a string value in Bicep with multiple placeholders that you want to replace, it can be tricky to find a good way to do this. In this blog post, I will show you how you can replace placeholders in a string with a couple of user-defined functions.

Apply Azure naming convention using Bicep functions

Wed, 05 Jun 2024 08:00:00 +0200

When deploying Azure resources, it’s a good practice to apply a naming convention to your resources. This will help you to identify the purpose of the resource and the environment it belongs to. In this blog post, I will show you how to apply a naming convention using Bicep user-defined functions. This post also includes a short introduction to the (experimental) Bicep Testing Framework.

Securing backend connections with mTLS in API Management

Fri, 24 May 2024 10:15:00 +0200

In this third post on working with client certificates in Azure API Management, we’ll focus on securing backend connections with mTLS. Using Bicep, we’ll reference a client certificate stored in Key Vault, make it available in API Management and configure a backend resource that uses the certificate during the mTLS handshake.

Validate client certificates in API Management when it's behind an Application Gateway

Mon, 19 Feb 2024 19:00:00 +0100

It’s not uncommon for Azure API Management to be deployed in a Virtual Network, only allowing external access via an Azure Application Gateway. In this second post on working with client certificates in API Management, we’ll explore how to configure an Application Gateway for mTLS and forward the client certificate to API Management for further validation. We’ll also look at the difference between strict and passthrough modes.

Validate client certificates in API Management

Fri, 02 Feb 2024 11:00:00 +0100

This blog post is the start of a series on how to work with client certificates in Azure API Management to set up a mutual TLS (mTLS) connection. While Azure’s official documentation provides excellent guidance on setting up client certificates via the Azure Portal, we’ll dive into using Bicep to automate the process. In this first post, we’ll cover the basics of how to validate client certificates in API Management.

Where to position SpecFlow in the Test Pyramid?

Thu, 11 May 2023 20:45:00 +0200

Automated testing is an essential part of software development, and determining the appropriate scope for your tests is crucial. This is also true when automating Gherkin scenarios with SpecFlow (or Cucumber). In this post I explore the different levels of the test pyramid and describe my preferred level for SpecFlow tests.

Deploy Azure Workbook and App Insights Function

Fri, 10 Mar 2023 15:00:00 +0100

In this post I explain how to deploy an Azure workbook using Bicep and set environment specific variables. I’ll also show how to deploy a shared kusto function in Application Insights with the Azure CLI.

Azure Workbook Tips & Tricks

Tue, 28 Feb 2023 19:30:00 +0100

If you use Azure, you most likely use Application Insights for logging. You can use a dashboard to visualize your logging and gain better insights, but dashboards come with some limitations. For more flexibility Azure has worbooks. In this blog post I’ll share some tips & tricks that I’ve gathered over the years. As a sample, we’ll create a workbook that shows information about requests sent to an API Management instance.

Transform SpecFlow Table Column

Sat, 29 Oct 2022 12:30:00 +0200

In a previous blog post I wrote about a trick on how to remove technical ids from Gherkin scenarios while still using technical ids in the step definitions. The proposed solution worked well for the given scenario, but not for other cases. In this post I look at several approaches on how to solve this issue.

Handling exceptions in SpecFlow

Mon, 31 May 2021 07:30:00 +0200

I use Gherkin scenarios to describe the functional specifications of my software and SpecFlow to automate these scenarios as tests. Usually there will be a couple of scenarios describing the happy path of the feature I’m building but also some scenarios concerning failures. In this post I’ll show my solution how to handle failures in the form of exceptions with the Driver pattern.

Provision an Azure VM in an Azure Pipelines Environment

Tue, 16 Mar 2021 00:00:00 +0100

In the past I’ve created a custom Azure Pipelines task to install .NET Core on a Windows server. To test this task, I had to manually setup an environment with virtual machines. I wanted to automate this process, so I created a YAML pipeline in Azure DevOps that automatically provisions an Azure virtual machine and registers the virtual machine in an Azure Pipelines environment.

Handling technical ids in Gherkin with SpecFlow

Sat, 08 Aug 2020 00:00:00 +0200

Gherkin scenarios in Specification by Example are used to describe the functional requirements of your software. They should be readable for the team and also for the business that uses the software. Technical ids don’t have a place here. They’re usually included in scenarios for test automation purposes but make the them harder to read. So, what to do when your code requires a technical id?

How to install .NET Core on a Windows server

Thu, 07 May 2020 00:00:00 +0200

In this post I show how I install and update the .NET Core Runtime & Hosting Bundle on Windows servers using Azure Pipelines. Making patching .NET Core a trivial matter.

Using multi-stage YAML pipeline to create and publish NuGet packages

Tue, 03 Sep 2019 00:00:00 +0100

I’ve recently created a new NuGet package called FluentAssertions.ArgumentMatchers.Moq that I published on nuget.org. In order to make the process of creating and publishing this package as smooth and simple as possible, I’ve created a multi-stage YAML pipeline in Azure DevOps.

Build And Release Hugo Site Using Azure Pipelines

Sun, 24 Mar 2019 00:00:00 +0100

In this post I’ll give a step-by-step explanation on how I build and publish my Hugo blog site to GitHub Pages using Azure Pipelines.

Cleaning Up Your Test Data Creation

Wed, 20 Mar 2019 00:00:00 +0100

I still come across a lot of automated tests with many lines of code just to create an object. Even when most data is not relevant for the scenario being tested.