DEV Community: Mark Wragg

A PowerShell currency conversion module

Mark Wragg — Mon, 26 Oct 2026 14:41:24 +0000

GitHub: https://github.com/markwragg/PowerShell-CurrencyConverter

Two and a half years ago, I published a module to the PowerShell Gallery (the official Microsoft nuget repository for PowerShell scripts and modules) called CurrencyConverter. It came from another module I was working on called AzCostTools, in which I found I had a need to convert cost data that I was exporting out of Azure, into a local currency.

I originally blogged about this here: https://wragg.io/Perform-currency-conversion-with-PowerShell/

I wanted my AzCostTools module to be able to convert currency without the user having to sign up for a service and provide an API key, which led me to ExchangeRate-API, which provides an open API for currency conversion. CurrencyConverter uses this by default when converting Fiat (traditional, government-issued) currencies. This API refreshes daily, so you are not necessarily getting an exact exchange rate, but probably something that is close enough for general use. You can sign up to ExchangeRate-API if you want rates that are updated more frequently, and CurrencyConverter then supports this, you just provide your key via the -ApiKey parameter.

A short while after I published the module, someone raised an issue on GitHub asking if it could support Crypto currencies. ExchangeRate-API didn't offer this, but I discovered there was an open API for crypto currencies provided by CoinBase, so I added some additional cmdlets to wrap this API and allow for the conversion of these currencies.

Installation

Because the module is published to the PowerShell Gallery, you can install it using PowerShell's package management cmdlets:

Install-Module CurrencyConverter

Or if you'd like to inspect the code directly, get it from GitHub.

The module is cross-platform, and has been tested on Windows (via Windows PowerShell and PowerShell 7), MacOS and Linux.

When I write a PowerShell module that wraps an API, I try to go beyond just returning the results of that API (because if that was all it did, you might as well just use Invoke-RestMethod). Although it is nice that PowerShell cmdlets allow you to extrapolate away the need for a user to know how to craft an API request (by providing parameter inputs instead), and also potentially finesse the results, returned as PowerShell objects that can then be further interrogated and manipulated.

Cmdlets

CurrencyConverter's initial cmdlets were as follows:

Convert-Currency

Convert-Currency allows you to convert a decimal value between two currencies, and returns a decimal value result. You can provide the value via the -Value parameter, or via the pipeline (which can be one or more values):

Convert-Currency -Value 100 -From USD -To GBP

74.778300

100,150,200 | Convert-Currency -From EUR -To JPY

17584.342200
26376.513300
35168.684400

Note that there's parameter validation on the -From and -To parameters with the codes for all of the supported currencies, so you can just tab through the various codes (and it will reject ones that are not supported).

Get-Currency

Get-Currency allows you to list all supported currencies:

Get-Currency

Code Name                          Country
---- ----                          -------
AED  UAE Dirham                    United Arab Emirates
AFN  Afghan Afghani                Afghanistan
ALL  Albanian Lek                  Albania
AMD  Armenian Dram                 Armenia
ANG  Netherlands Antillian Guilder Netherlands Antilles
AOA  Angolan Kwanza                Angola
ARS  Argentine Peso                Argentina
...

Which you can also use to discover a currency, by providing its code or country, for example:

Get-Currency -Country Singapore

Code Name             Country
---- ----             -------
SGD  Singapore Dollar Singapore

Format-Currency

Format-Currency returns a formatted string for a specified currency, including the currency symbol and rounded to two decimal places:

100 | Format-Currency -Currency USD

$100.00

Which you can chain from Convert-Currency (or any PowerShell script or command that returns a decimal value):

100 | Convert-Currency -From USD -To EUR | Format-Currency

€89.21

Note that the destination currency is included as a NoteProperty output from Convert-Currency which then allows it to be received as an input by Format-Currency and avoids it having to be specified manually. If you were just providing a value directly to Format-Currency then you'd need to specify the currency as an input:

100 | Format-Currency -Currency EUR

€100.00

In some cultures, the currency symbol is written after the amount. You can have Format-Currency do this by specifying -SymbolAtEnd:

100 | Format-Currency -Currency EUR -SymbolAtEnd

100.00€

Get-ExchangeRate

Get-ExchangeRate returns all (supported) exchange rates for a specified currency, or a specified exchange rate between two currencies:

Get-ExchangeRate -Currency USD

result                : success
provider              : https://www.exchangerate-api.com
documentation         : https://www.exchangerate-api.com/docs/free
terms_of_use          : https://www.exchangerate-api.com/terms
time_last_update_unix : 1792972951
time_last_update_utc  : Mon, 26 Oct 2026 00:02:31 +0000
time_next_update_unix : 1793060461
time_next_update_utc  : Tue, 27 Oct 2026 00:21:01 +0000
time_eol_unix         : 0
base_code             : USD
rates                 : @{USD=1; AED=3.6725; AFN=64.826446; ...

Note this returns the full API result, and the actual exchange rates are in the rates property when using the Open API, or conversion_rates when using an API key. If you just want to return the exchange rates (regardless of which API you're using) then specify -Rates:

Get-ExchangeRate -Currency GBP -Rates

GBP : 1
AED : 4.910876
AFN : 86.523878
ALL : 108.353838
AMD : 482.971946
...

Convert-CryptoCurrency, Get-CryptoCurrency, Get-CryptoExchangeRate

Crypto currencies have their own set of cmdlets, which work largely the same as those above, but against the Coinbase API. The cmdlets for these are:

Convert-CryptoCurrency - E.g 100 | Convert-CryptoCurrency -From GBP -To BTC
Get-CryptoCurrency - E.g Get-CryptoCurrency -Name Omni
Get-CryptoExchangeRate - E.g Get-CryptoExchangeRate -From GBP -To BTC

These allow conversion between Fiat and crypto currencies.

You can use Format-Currency with a crypto currency as well:

23.45 | Convert-CryptoCurrency -From BTC -To ETH | Format-Currency

Ξ4,270.89

Set-CurrencyDefault, Get-CurrencyDefault

Over the last week (with the aid of AI) I've added some extra functionality to the module. You can now save defaults via a new Set-CurrencyDefault cmdlet. This is useful if you're always converting to or from the same currencies (more likely from than to perhaps) or if you want to use an ExchangeRate-API API key and not provide it every time you use the cmdlet. For example:

Set-CurrencyDefault -From GBP -APIKey yourapikeyhere

These are saved as JSON under your $Home directory in a folder called .currencyconverter, so that they will persist if/when you upgrade the module in the future. You can see what defaults you have saved by running Get-CurrencyDefault.

Once a default is set, you don't need to specify it anymore, so for example, this will now assume I am converting British Pounds (GBP):

100 | Convert-Currency -To USD

133.728700

Add-CurrencyMember

I also added a cmdlet called Add-CurrencyMember. This is inspired by PowerShell's built in Add-Member cmdlet, which you can use to append a new property to an existing PowerShell object. Add-CurrencyMember allows you to append one or more additional properties to an object that are a currency conversion of an existing object. This is useful where you have a set of data in PowerShell that you want to convert a currency column of data for. For example, say you have a collection of products (this could have been loaded from a CSV for example, but we'll just create a simple PowerShell array of objects as an example):

$Products = @(
  [pscustomobject]@{ Product = 'Widget'; Price = 100 }
  [pscustomobject]@{ Product = 'Gizmo'; Price = 75 }
  [pscustomobject]@{ Product = 'Sprocket'; Price = 125 }
)

But the Price was USD, and you wanted it in EUR. You could do:

$Products | Add-CurrencyMember -Property Price -From USD -To EUR
$Products

Product  Price PriceEUR
-------  ----- --------
Widget     100    89.21
Gizmo       75    66.91
Sprocket   125   111.52

You can specify exactly what you want the new property name to be by providing -MemberName, and have the results returned immediately to the pipeline via -PassThru:

$Products | Add-CurrencyMember -Property Price -From USD -To EUR -MemberName PriceInEuro -PassThru

plaintext

Product  Price PriceInEuro
-------  ----- -----------
Widget     100       89.21
Gizmo       75       66.91
Sprocket   125      111.52

Note that while the default output is two decimal place, the PowerShell object does actually hold the exact decimal value:

Product     : Widget
Price       : 100
PriceInEuro : 89.21300

Product     : Gizmo
Price       : 75
PriceInEuro : 66.90975

Product     : Sprocket
Price       : 125
PriceInEuro : 111.51625

ConvertTo-CurrencyTable

If you need to convert a value to multiple destination currencies, you can now do so via the ConvertTo-CurrencyTable cmdlet. This outputs a PowerShell object with each currencies value as a named property. For example:

100,150,200 | ConvertTo-CurrencyTable -From GBP -To USD,CAD,EUR

   GBP    USD    CAD    EUR
   ---    ---    ---    ---
100.00 133.73 187.40 119.30
150.00 200.59 281.09 178.95
200.00 267.46 374.79 238.60

Watch-ExchangeRate

If you want to monitor an exchange rate for change, there's now a Watch-ExchangeRate cmdlet. This will check a specified rate at a specified interval (60 seconds by default) and stop when it has moved up or down beyond a specified threshold. For example, this will monitor the British Pound to Bitcoin exchange rate, until it rises above 0.0000167346063796:

Watch-ExchangeRate -From GBP -To BTC -IntervalSeconds 5 -AboveThreshold 0.0000167346063796 | FT

From To  Rate               Timestamp           Triggered
---- --  ----               ---------           ---------
GBP  BTC 0.0000167346063795 26/10/2026 14:32:05     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:12     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:17     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:23     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:29     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:35     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:42     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:48     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:53     False
GBP  BTC 0.0000167346063795 26/10/2026 14:32:58     False
GBP  BTC 0.0000167346063795 26/10/2026 14:33:04     False
GBP  BTC 0.0000167548698867 26/10/2026 14:33:10      True

Obviously this is limited by how frequently the exchange rate API provides refreshed rates, and polling the open APIs too frequently may result in your being rate limited.

Historical Exchange Rates

Finally, Get-ExchangeRate, Convert-Currency, ConvertTo-CurrencyTable and Add-CurrencyMember now support a -Date parameter, which allows you to query a historical rate for a specified currency. This is only supported for Fiat currencies, as historical data comes only from ExchangeRate-API, and also requires you to specify an API key, because historical data is not accessible via the open API. For example:

Convert-Currency -Value 100 -From USD -To GBP -Date '2024-01-15' -ApiKey yourapikeystringhere

Conclusion

This concludes this overview of the CurrencyConverter module. As previously mentioned, you can get it from the PowerShell Gallery or GitHub where there is also a detailed Wiki, which includes the PowerShell help output for each cmdlet giving further usage explanation and examples.

If you encounter any bugs or have any suggestions, please do log an issue:

https://github.com/markwragg/PowerShell-CurrencyConverter/issues

Contributions are welcomed.

Two ways to use Pester to Mock objects with strongly typed parameters

Mark Wragg — Thu, 24 Oct 2024 17:43:16 +0000

When writing Pester unit tests, it's pretty common to want to Mock cmdlets so that you can validate they've been called when expected, and the expected number of times.

BeforeAll {
  Mock "Some-Command" -MockWith {}
}

It "Should invoke Some-Command the expected number of times" {
  Should -Invoke "Some-Command" -Times 1 -Exactly
}

Some commands however can be difficult to Mock because one of more of their input parameters requires a specific type of object. An example of this is the Azure storage cmdlet New-AzStorageContext. This creates a Microsoft.WindowsAzure.Commands.Storage.AzureStorageContext type object, which other storage cmdlets then expect as an input.

There's two ways to handle this:

1. Use New-MockObject

The New-MockObject Pester cmdlet allows you to create an object of a specified type, with the properties and methods that you require. For New-AzStorageContext you could do something like this:

Mock New-AzStorageContext -MockWith {
  New-MockObject -Type Microsoft.WindowsAzure.Commands.Storage.AzureStorageContext -Properties @{
    StorageAccountName = 'somestorageaccount'
    Context            = @{
    StorageAccountName = 'somestorageaccount'
    }
  }
}

However for New-MockObject to work, the type you want to fake has to be available on the system (i.e the relevant module/cmdlets must be installed).

2. Use -RemoveParameterType

The alternative option is to use the -RemoveParameterType parameter on the Mock that needs to receive the strongly typed object. This removes the strong typing on the specified input parameter and means that you can therefore Mock the source object's output as just a [pscustomobject]. For example:

Mock New-AzStorageContext -MockWith {
  [pscustomobject]@{
    StorageAccountName = 'somestorageaccount'
    Context            = @{
    StorageAccountName = 'somestorageaccount'
    }
  }
}

And then on the receiving Mock you do:

Mock Get-AzStorageTable -RemoveParameterType 'Context' -MockWith {
  [pscustomobject]@{
    Name       = 'sometable'
    CloudTable = @{ Name = 'somename' }
  }
}

This also negates the need for the type to be available on the system where your tests execute.

For more on Mocking with Pester see here.

How to remove null or empty string values from a list in Terraform

Mark Wragg — Tue, 22 Oct 2024 10:36:31 +0000

I was recently implementing a change to a Terraform azurerm_key_vault Key Vault resource to allow a specified list of IP addresses on the firewall. The IP addresses would be provided via an Azure DevOps variable, which would contain a comma-separated list. This list is then turned into a list value in Terraform via the split function.

I wanted the change to the resource to continue to work if the variable was not specified, but when no value was provided the result would be an empty string, and this was not a valid value for the ip_rules property of the Key Vault resource, which requires either null or a list of values.

The solution was to use the compact function. This takes a list of strings and removes any null or empty string elements:

resource "azurerm_key_vault" "keyvault" {
  name                = var.keyVaultName
  location            = var.location
  resource_group_name = var.rgName
  sku_name            = "standard"
  tenant_id           = data.azurerm_client_config.current.tenant_id

  network_acls {
    default_action = "Deny"
    ip_rules       = compact(split(",", var.keyVaultAllowedIPs))
  }
}

The compact function appears to have been a part of Terraform since at least version 1.1 but looking at the documentation it appears that it only started to remove null values from strings (as well as empty strings) as of version 1.5.

At time of writing the current production release of Terraform is 1.9.

Redirect Out-File to TestDrive: in your PowerShell Pester test scripts with this one weird trick

Mark Wragg — Sat, 19 Oct 2024 14:01:19 +0000

I was writing some Pester unit tests recently for a PowerShell script that creates a modified version of a template file before it is then uploaded via an API and deleted. The script uses Out-File to output the updated file and because it only exists temporarily the location it writes to is hard coded in the script.

I wanted to write some tests that would validate the file was created and with the expected updated values. I could have just let the script write the file to it's default location and validate it there, but I'd have to mock Remove-Item to stop it deleting the file and then have my test script remove it afterwards. Another approach might have been to do some refactoring, have the output file and input parameter of the script, or break the script up into smaller functions, but I didn't particularly want to change the script.

Pester provides an automatic location TestDrive: that can be used to isolate file operations somewhere unique and that it automatically cleans up when the test completes, so all I needed to do was override the behaviour of Out-File to write to TestDrive:. You can do that with a Mock, and the one-weird-trick here is to store the Out-File command into a variable so that we can use it within the Mock, but change it's input parameters:

BeforeAll {
  $OutFile = Get-Command -Name 'Out-File'

  Mock Out-File -ParameterFilter { $FilePath -match 'file.txt' } -MockWith {
    $InputObject = $PesterBoundParameters['InputObject']
    $FilePath = Join-Path $TestDrive 'file.txt'
    & $OutFile -InputObject $InputObject -FilePath $FilePath
  }
}

It 'Should update the file with the expected values' {

  $FilePath = (Join-Path $TestDrive 'file.txt')

  $FilePath | Should -FileContentMatch 'expectedstring1'
  $FilePath | Should -FileContentMatch 'expectedstring2'
  $FilePath | Should -FileContentMatch 'expectedstring3'
}

It is necessary to put the command into a variable because once a command is mocked in a test script, calling it would invoke the Mock rather than the command, so you'd end up in a recursive loop. Note how the Mock uses $PesterBoundParameters to access the parameters that were passed to the command in the script, but we then override what would have been provided for -FilePath with our TestDrive: pathed value.

My script still mocked Remove-Item btw, so we could check that it had been called the expected number of times. There was no need to let it actually do a file removal because the clean up of TestDrive: takes care of that for us. It's usually best to mock away the destructive behaviour of cmdlets when testing so that if the script has been badly modified in some way you don't risk invoking the actual behaviour for the purpose of running your tests.

Hi, I'm Mark Wragg

Mark Wragg — Fri, 05 May 2017 14:30:21 +0000

👋 Hi! I am an Azure DevOps Engineer from the UK. I live in Basingstoke with my wife and three small humans.

I've worked full-time in IT since graduating with a Degree in Computing in 2003, with the exception of a year out to give Teacher Training a whirl. Much of my initial IT career experience was working in front-line operations roles, supporting infrastructure and SaaS applications hosted in private data centres and the cloud. Since 2017 I've worked as a DevOps Engineer and for the last few years as a contractor. My experience is predominantly with Microsoft technologies but I can generally turn a quick hand to any tool and I have experience with AWS and Azure as well as a variety of DevOps toolsets.

You can follow me on Twitter @markwragg.

I am particularly passionate about PowerShell and have spoken twice at PSDay.UK, the UK's annual PowerShell Conference. If you'd like to view my talks they can be found here:

Public Speaking

Measure all the things with Influx, Grafana and PowerShell -- PSDay Birmingham 2019
Mastering PowerShell Testing with Pester -- PSDay London 2018
How to Develop Cross-Platform Compatible Modules using PowerShell Code -- Southampton PowerShell Usergroup 2018 (slides only, not recorded)

Books

I also made voluntary contributions to the following books, which raised funds for the DevOps Collective OnRamp scholarship:

The PowerShell Conference Book volume 1 -- contributed a chapter on PowerShell code testing with Pester
The PowerShell Conference Book volume 2 -- contributed a chapter on monitoring with Influx, Grafana and PowerShell

Open Source

I maintain a number of Open Source code repositories for tools that I've developed that I felt could be useful to the wider community. You can find those in my profile on GitHub. Some that are particularly popular include:

PowerShell-Influx -- a PowerShell module for sending metrics into the time-series platform Influx.
Test-ActiveDirectory -- a set of Pester tests for validating the health of a deployment of Active Directory.
PowerShell-SlackBot -- a PowerShell module for hosting a chat bot for Slack using PowerShell and TCP Sockets. The chat bot can then be configured to listen to and respond to specific messages and run PowerShell commands that are initiated from within a chat window.

If you have any other burning questions about me, feel free to get in touch! :)